1 // Copyright 2014 The Chromium OS Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file.
4
5 #include "chromeos-dbus-bindings/proxy_generator.h"
6
7 #include <string>
8 #include <vector>
9
10 #include <base/files/file_path.h>
11 #include <base/files/file_util.h>
12 #include <base/files/scoped_temp_dir.h>
13 #include <gtest/gtest.h>
14
15 #include "chromeos-dbus-bindings/interface.h"
16 #include "chromeos-dbus-bindings/test_utils.h"
17
18 using std::string;
19 using std::vector;
20 using testing::Test;
21
22 namespace chromeos_dbus_bindings {
23
24 namespace {
25
26 const char kDBusTypeArryOfObjects[] = "ao";
27 const char kDBusTypeArryOfStrings[] = "as";
28 const char kDBusTypeBool[] = "b";
29 const char kDBusTypeByte[] = "y";
30 const char kDBusTypeInt32[] = "i";
31 const char kDBusTypeInt64[] = "x";
32 const char kDBusTypeString[] = "s";
33
34 const char kExpectedContent[] = R"literal_string(
35 #include <memory>
36 #include <string>
37 #include <vector>
38
39 #include <base/bind.h>
40 #include <base/callback.h>
41 #include <base/logging.h>
42 #include <base/macros.h>
43 #include <base/memory/ref_counted.h>
44 #include <brillo/any.h>
45 #include <brillo/dbus/dbus_method_invoker.h>
46 #include <brillo/dbus/dbus_property.h>
47 #include <brillo/dbus/dbus_signal_handler.h>
48 #include <brillo/errors/error.h>
49 #include <brillo/variant_dictionary.h>
50 #include <dbus/bus.h>
51 #include <dbus/message.h>
52 #include <dbus/object_manager.h>
53 #include <dbus/object_path.h>
54 #include <dbus/object_proxy.h>
55
56 namespace org {
57 namespace chromium {
58
59 // Abstract interface proxy for org::chromium::TestInterface.
60 class TestInterfaceProxyInterface {
61 public:
62 virtual ~TestInterfaceProxyInterface() = default;
63
64 virtual bool Elements(
65 const std::string& in_space_walk,
66 const std::vector<dbus::ObjectPath>& in_ramblin_man,
67 std::string* out_3,
68 brillo::ErrorPtr* error,
69 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
70
71 virtual void ElementsAsync(
72 const std::string& in_space_walk,
73 const std::vector<dbus::ObjectPath>& in_ramblin_man,
74 const base::Callback<void(const std::string&)>& success_callback,
75 const base::Callback<void(brillo::Error*)>& error_callback,
76 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
77
78 virtual bool ReturnToPatagonia(
79 int64_t* out_1,
80 brillo::ErrorPtr* error,
81 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
82
83 virtual void ReturnToPatagoniaAsync(
84 const base::Callback<void(int64_t)>& success_callback,
85 const base::Callback<void(brillo::Error*)>& error_callback,
86 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
87
88 virtual bool NiceWeatherForDucks(
89 bool in_1,
90 brillo::ErrorPtr* error,
91 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
92
93 virtual void NiceWeatherForDucksAsync(
94 bool in_1,
95 const base::Callback<void()>& success_callback,
96 const base::Callback<void(brillo::Error*)>& error_callback,
97 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
98
99 // Comment line1
100 // line2
101 virtual bool ExperimentNumberSix(
102 brillo::ErrorPtr* error,
103 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
104
105 // Comment line1
106 // line2
107 virtual void ExperimentNumberSixAsync(
108 const base::Callback<void()>& success_callback,
109 const base::Callback<void(brillo::Error*)>& error_callback,
110 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
111
112 virtual void RegisterCloserSignalHandler(
113 const base::Closure& signal_callback,
114 dbus::ObjectProxy::OnConnectedCallback on_connected_callback) = 0;
115
116 virtual void RegisterTheCurseOfKaZarSignalHandler(
117 const base::Callback<void(const std::vector<std::string>&,
118 uint8_t)>& signal_callback,
119 dbus::ObjectProxy::OnConnectedCallback on_connected_callback) = 0;
120
121 virtual const dbus::ObjectPath& GetObjectPath() const = 0;
122 };
123
124 } // namespace chromium
125 } // namespace org
126
127 namespace org {
128 namespace chromium {
129
130 // Interface proxy for org::chromium::TestInterface.
131 class TestInterfaceProxy final : public TestInterfaceProxyInterface {
132 public:
133 TestInterfaceProxy(
134 const scoped_refptr<dbus::Bus>& bus,
135 const std::string& service_name) :
136 bus_{bus},
137 service_name_{service_name},
138 dbus_object_proxy_{
139 bus_->GetObjectProxy(service_name_, object_path_)} {
140 }
141
142 ~TestInterfaceProxy() override {
143 }
144
145 void RegisterCloserSignalHandler(
146 const base::Closure& signal_callback,
147 dbus::ObjectProxy::OnConnectedCallback on_connected_callback) override {
148 brillo::dbus_utils::ConnectToSignal(
149 dbus_object_proxy_,
150 "org.chromium.TestInterface",
151 "Closer",
152 signal_callback,
153 on_connected_callback);
154 }
155
156 void RegisterTheCurseOfKaZarSignalHandler(
157 const base::Callback<void(const std::vector<std::string>&,
158 uint8_t)>& signal_callback,
159 dbus::ObjectProxy::OnConnectedCallback on_connected_callback) override {
160 brillo::dbus_utils::ConnectToSignal(
161 dbus_object_proxy_,
162 "org.chromium.TestInterface",
163 "TheCurseOfKaZar",
164 signal_callback,
165 on_connected_callback);
166 }
167
168 void ReleaseObjectProxy(const base::Closure& callback) {
169 bus_->RemoveObjectProxy(service_name_, object_path_, callback);
170 }
171
172 const dbus::ObjectPath& GetObjectPath() const override {
173 return object_path_;
174 }
175
176 dbus::ObjectProxy* GetObjectProxy() const { return dbus_object_proxy_; }
177
178 bool Elements(
179 const std::string& in_space_walk,
180 const std::vector<dbus::ObjectPath>& in_ramblin_man,
181 std::string* out_3,
182 brillo::ErrorPtr* error,
183 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
184 auto response = brillo::dbus_utils::CallMethodAndBlockWithTimeout(
185 timeout_ms,
186 dbus_object_proxy_,
187 "org.chromium.TestInterface",
188 "Elements",
189 error,
190 in_space_walk,
191 in_ramblin_man);
192 return response && brillo::dbus_utils::ExtractMethodCallResults(
193 response.get(), error, out_3);
194 }
195
196 void ElementsAsync(
197 const std::string& in_space_walk,
198 const std::vector<dbus::ObjectPath>& in_ramblin_man,
199 const base::Callback<void(const std::string&)>& success_callback,
200 const base::Callback<void(brillo::Error*)>& error_callback,
201 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
202 brillo::dbus_utils::CallMethodWithTimeout(
203 timeout_ms,
204 dbus_object_proxy_,
205 "org.chromium.TestInterface",
206 "Elements",
207 success_callback,
208 error_callback,
209 in_space_walk,
210 in_ramblin_man);
211 }
212
213 bool ReturnToPatagonia(
214 int64_t* out_1,
215 brillo::ErrorPtr* error,
216 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
217 auto response = brillo::dbus_utils::CallMethodAndBlockWithTimeout(
218 timeout_ms,
219 dbus_object_proxy_,
220 "org.chromium.TestInterface",
221 "ReturnToPatagonia",
222 error);
223 return response && brillo::dbus_utils::ExtractMethodCallResults(
224 response.get(), error, out_1);
225 }
226
227 void ReturnToPatagoniaAsync(
228 const base::Callback<void(int64_t)>& success_callback,
229 const base::Callback<void(brillo::Error*)>& error_callback,
230 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
231 brillo::dbus_utils::CallMethodWithTimeout(
232 timeout_ms,
233 dbus_object_proxy_,
234 "org.chromium.TestInterface",
235 "ReturnToPatagonia",
236 success_callback,
237 error_callback);
238 }
239
240 bool NiceWeatherForDucks(
241 bool in_1,
242 brillo::ErrorPtr* error,
243 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
244 auto response = brillo::dbus_utils::CallMethodAndBlockWithTimeout(
245 timeout_ms,
246 dbus_object_proxy_,
247 "org.chromium.TestInterface",
248 "NiceWeatherForDucks",
249 error,
250 in_1);
251 return response && brillo::dbus_utils::ExtractMethodCallResults(
252 response.get(), error);
253 }
254
255 void NiceWeatherForDucksAsync(
256 bool in_1,
257 const base::Callback<void()>& success_callback,
258 const base::Callback<void(brillo::Error*)>& error_callback,
259 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
260 brillo::dbus_utils::CallMethodWithTimeout(
261 timeout_ms,
262 dbus_object_proxy_,
263 "org.chromium.TestInterface",
264 "NiceWeatherForDucks",
265 success_callback,
266 error_callback,
267 in_1);
268 }
269
270 // Comment line1
271 // line2
272 bool ExperimentNumberSix(
273 brillo::ErrorPtr* error,
274 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
275 auto response = brillo::dbus_utils::CallMethodAndBlockWithTimeout(
276 timeout_ms,
277 dbus_object_proxy_,
278 "org.chromium.TestInterface",
279 "ExperimentNumberSix",
280 error);
281 return response && brillo::dbus_utils::ExtractMethodCallResults(
282 response.get(), error);
283 }
284
285 // Comment line1
286 // line2
287 void ExperimentNumberSixAsync(
288 const base::Callback<void()>& success_callback,
289 const base::Callback<void(brillo::Error*)>& error_callback,
290 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
291 brillo::dbus_utils::CallMethodWithTimeout(
292 timeout_ms,
293 dbus_object_proxy_,
294 "org.chromium.TestInterface",
295 "ExperimentNumberSix",
296 success_callback,
297 error_callback);
298 }
299
300 private:
301 scoped_refptr<dbus::Bus> bus_;
302 std::string service_name_;
303 const dbus::ObjectPath object_path_{"/org/chromium/Test"};
304 dbus::ObjectProxy* dbus_object_proxy_;
305
306 DISALLOW_COPY_AND_ASSIGN(TestInterfaceProxy);
307 };
308
309 } // namespace chromium
310 } // namespace org
311
312 namespace org {
313 namespace chromium {
314
315 // Abstract interface proxy for org::chromium::TestInterface2.
316 class TestInterface2ProxyInterface {
317 public:
318 virtual ~TestInterface2ProxyInterface() = default;
319
320 virtual bool GetPersonInfo(
321 std::string* out_name,
322 int32_t* out_age,
323 brillo::ErrorPtr* error,
324 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
325
326 virtual void GetPersonInfoAsync(
327 const base::Callback<void(const std::string& /*name*/, int32_t /*age*/)>& success_callback,
328 const base::Callback<void(brillo::Error*)>& error_callback,
329 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
330
331 virtual const dbus::ObjectPath& GetObjectPath() const = 0;
332 };
333
334 } // namespace chromium
335 } // namespace org
336
337 namespace org {
338 namespace chromium {
339
340 // Interface proxy for org::chromium::TestInterface2.
341 class TestInterface2Proxy final : public TestInterface2ProxyInterface {
342 public:
343 TestInterface2Proxy(
344 const scoped_refptr<dbus::Bus>& bus,
345 const std::string& service_name,
346 const dbus::ObjectPath& object_path) :
347 bus_{bus},
348 service_name_{service_name},
349 object_path_{object_path},
350 dbus_object_proxy_{
351 bus_->GetObjectProxy(service_name_, object_path_)} {
352 }
353
354 ~TestInterface2Proxy() override {
355 }
356
357 void ReleaseObjectProxy(const base::Closure& callback) {
358 bus_->RemoveObjectProxy(service_name_, object_path_, callback);
359 }
360
361 const dbus::ObjectPath& GetObjectPath() const override {
362 return object_path_;
363 }
364
365 dbus::ObjectProxy* GetObjectProxy() const { return dbus_object_proxy_; }
366
367 bool GetPersonInfo(
368 std::string* out_name,
369 int32_t* out_age,
370 brillo::ErrorPtr* error,
371 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
372 auto response = brillo::dbus_utils::CallMethodAndBlockWithTimeout(
373 timeout_ms,
374 dbus_object_proxy_,
375 "org.chromium.TestInterface2",
376 "GetPersonInfo",
377 error);
378 return response && brillo::dbus_utils::ExtractMethodCallResults(
379 response.get(), error, out_name, out_age);
380 }
381
382 void GetPersonInfoAsync(
383 const base::Callback<void(const std::string& /*name*/, int32_t /*age*/)>& success_callback,
384 const base::Callback<void(brillo::Error*)>& error_callback,
385 int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
386 brillo::dbus_utils::CallMethodWithTimeout(
387 timeout_ms,
388 dbus_object_proxy_,
389 "org.chromium.TestInterface2",
390 "GetPersonInfo",
391 success_callback,
392 error_callback);
393 }
394
395 private:
396 scoped_refptr<dbus::Bus> bus_;
397 std::string service_name_;
398 dbus::ObjectPath object_path_;
399 dbus::ObjectProxy* dbus_object_proxy_;
400
401 DISALLOW_COPY_AND_ASSIGN(TestInterface2Proxy);
402 };
403
404 } // namespace chromium
405 } // namespace org
406 )literal_string";
407
408 const char kExpectedContentWithService[] = R"literal_string(
409 #include <memory>
410 #include <string>
411 #include <vector>
412
413 #include <base/bind.h>
414 #include <base/callback.h>
415 #include <base/logging.h>
416 #include <base/macros.h>
417 #include <base/memory/ref_counted.h>
418 #include <brillo/any.h>
419 #include <brillo/dbus/dbus_method_invoker.h>
420 #include <brillo/dbus/dbus_property.h>
421 #include <brillo/dbus/dbus_signal_handler.h>
422 #include <brillo/errors/error.h>
423 #include <brillo/variant_dictionary.h>
424 #include <dbus/bus.h>
425 #include <dbus/message.h>
426 #include <dbus/object_manager.h>
427 #include <dbus/object_path.h>
428 #include <dbus/object_proxy.h>
429
430 namespace org {
431 namespace chromium {
432
433 // Abstract interface proxy for org::chromium::TestInterface.
434 class TestInterfaceProxyInterface {
435 public:
436 virtual ~TestInterfaceProxyInterface() = default;
437
438 virtual void RegisterCloserSignalHandler(
439 const base::Closure& signal_callback,
440 dbus::ObjectProxy::OnConnectedCallback on_connected_callback) = 0;
441
442 virtual const dbus::ObjectPath& GetObjectPath() const = 0;
443 };
444
445 } // namespace chromium
446 } // namespace org
447
448 namespace org {
449 namespace chromium {
450
451 // Interface proxy for org::chromium::TestInterface.
452 class TestInterfaceProxy final : public TestInterfaceProxyInterface {
453 public:
454 TestInterfaceProxy(const scoped_refptr<dbus::Bus>& bus) :
455 bus_{bus},
456 dbus_object_proxy_{
457 bus_->GetObjectProxy(service_name_, object_path_)} {
458 }
459
460 ~TestInterfaceProxy() override {
461 }
462
463 void RegisterCloserSignalHandler(
464 const base::Closure& signal_callback,
465 dbus::ObjectProxy::OnConnectedCallback on_connected_callback) override {
466 brillo::dbus_utils::ConnectToSignal(
467 dbus_object_proxy_,
468 "org.chromium.TestInterface",
469 "Closer",
470 signal_callback,
471 on_connected_callback);
472 }
473
474 void ReleaseObjectProxy(const base::Closure& callback) {
475 bus_->RemoveObjectProxy(service_name_, object_path_, callback);
476 }
477
478 const dbus::ObjectPath& GetObjectPath() const override {
479 return object_path_;
480 }
481
482 dbus::ObjectProxy* GetObjectProxy() const { return dbus_object_proxy_; }
483
484 private:
485 scoped_refptr<dbus::Bus> bus_;
486 const std::string service_name_{"org.chromium.Test"};
487 const dbus::ObjectPath object_path_{"/org/chromium/Test"};
488 dbus::ObjectProxy* dbus_object_proxy_;
489
490 DISALLOW_COPY_AND_ASSIGN(TestInterfaceProxy);
491 };
492
493 } // namespace chromium
494 } // namespace org
495
496 namespace org {
497 namespace chromium {
498
499 // Abstract interface proxy for org::chromium::TestInterface2.
500 class TestInterface2ProxyInterface {
501 public:
502 virtual ~TestInterface2ProxyInterface() = default;
503
504 virtual const dbus::ObjectPath& GetObjectPath() const = 0;
505 };
506
507 } // namespace chromium
508 } // namespace org
509
510 namespace org {
511 namespace chromium {
512
513 // Interface proxy for org::chromium::TestInterface2.
514 class TestInterface2Proxy final : public TestInterface2ProxyInterface {
515 public:
516 TestInterface2Proxy(
517 const scoped_refptr<dbus::Bus>& bus,
518 const dbus::ObjectPath& object_path) :
519 bus_{bus},
520 object_path_{object_path},
521 dbus_object_proxy_{
522 bus_->GetObjectProxy(service_name_, object_path_)} {
523 }
524
525 ~TestInterface2Proxy() override {
526 }
527
528 void ReleaseObjectProxy(const base::Closure& callback) {
529 bus_->RemoveObjectProxy(service_name_, object_path_, callback);
530 }
531
532 const dbus::ObjectPath& GetObjectPath() const override {
533 return object_path_;
534 }
535
536 dbus::ObjectProxy* GetObjectProxy() const { return dbus_object_proxy_; }
537
538 private:
539 scoped_refptr<dbus::Bus> bus_;
540 const std::string service_name_{"org.chromium.Test"};
541 dbus::ObjectPath object_path_;
542 dbus::ObjectProxy* dbus_object_proxy_;
543
544 DISALLOW_COPY_AND_ASSIGN(TestInterface2Proxy);
545 };
546
547 } // namespace chromium
548 } // namespace org
549 )literal_string";
550
551 const char kExpectedContentWithObjectManager[] = R"literal_string(
552 #include <memory>
553 #include <string>
554 #include <vector>
555
556 #include <base/bind.h>
557 #include <base/callback.h>
558 #include <base/logging.h>
559 #include <base/macros.h>
560 #include <base/memory/ref_counted.h>
561 #include <brillo/any.h>
562 #include <brillo/dbus/dbus_method_invoker.h>
563 #include <brillo/dbus/dbus_property.h>
564 #include <brillo/dbus/dbus_signal_handler.h>
565 #include <brillo/errors/error.h>
566 #include <brillo/variant_dictionary.h>
567 #include <dbus/bus.h>
568 #include <dbus/message.h>
569 #include <dbus/object_manager.h>
570 #include <dbus/object_path.h>
571 #include <dbus/object_proxy.h>
572
573 namespace org {
574 namespace chromium {
575 class ObjectManagerProxy;
576 } // namespace chromium
577 } // namespace org
578
579 namespace org {
580 namespace chromium {
581
582 // Abstract interface proxy for org::chromium::Itf1.
583 class Itf1ProxyInterface {
584 public:
585 virtual ~Itf1ProxyInterface() = default;
586
587 virtual void RegisterCloserSignalHandler(
588 const base::Closure& signal_callback,
589 dbus::ObjectProxy::OnConnectedCallback on_connected_callback) = 0;
590
591 static const char* DataName() { return "Data"; }
592 virtual const std::string& data() const = 0;
593 static const char* NameName() { return "Name"; }
594 virtual const std::string& name() const = 0;
595 virtual void set_name(const std::string& value,
596 const base::Callback<void(bool)>& callback) = 0;
597
598 virtual const dbus::ObjectPath& GetObjectPath() const = 0;
599
600 virtual void SetPropertyChangedCallback(
601 const base::Callback<void(Itf1ProxyInterface*, const std::string&)>& callback) = 0;
602 };
603
604 } // namespace chromium
605 } // namespace org
606
607 namespace org {
608 namespace chromium {
609
610 // Interface proxy for org::chromium::Itf1.
611 class Itf1Proxy final : public Itf1ProxyInterface {
612 public:
613 class PropertySet : public dbus::PropertySet {
614 public:
615 PropertySet(dbus::ObjectProxy* object_proxy,
616 const PropertyChangedCallback& callback)
617 : dbus::PropertySet{object_proxy,
618 "org.chromium.Itf1",
619 callback} {
620 RegisterProperty(DataName(), &data);
621 RegisterProperty(NameName(), &name);
622 }
623
624 brillo::dbus_utils::Property<std::string> data;
625 brillo::dbus_utils::Property<std::string> name;
626
627 private:
628 DISALLOW_COPY_AND_ASSIGN(PropertySet);
629 };
630
631 Itf1Proxy(
632 const scoped_refptr<dbus::Bus>& bus,
633 const std::string& service_name,
634 PropertySet* property_set) :
635 bus_{bus},
636 service_name_{service_name},
637 property_set_{property_set},
638 dbus_object_proxy_{
639 bus_->GetObjectProxy(service_name_, object_path_)} {
640 }
641
642 ~Itf1Proxy() override {
643 }
644
645 void RegisterCloserSignalHandler(
646 const base::Closure& signal_callback,
647 dbus::ObjectProxy::OnConnectedCallback on_connected_callback) override {
648 brillo::dbus_utils::ConnectToSignal(
649 dbus_object_proxy_,
650 "org.chromium.Itf1",
651 "Closer",
652 signal_callback,
653 on_connected_callback);
654 }
655
656 void ReleaseObjectProxy(const base::Closure& callback) {
657 bus_->RemoveObjectProxy(service_name_, object_path_, callback);
658 }
659
660 const dbus::ObjectPath& GetObjectPath() const override {
661 return object_path_;
662 }
663
664 dbus::ObjectProxy* GetObjectProxy() const { return dbus_object_proxy_; }
665
666 void SetPropertyChangedCallback(
667 const base::Callback<void(Itf1ProxyInterface*, const std::string&)>& callback) override {
668 on_property_changed_ = callback;
669 }
670
671 const PropertySet* GetProperties() const { return property_set_; }
672 PropertySet* GetProperties() { return property_set_; }
673
674 const std::string& data() const override {
675 return property_set_->data.value();
676 }
677
678 const std::string& name() const override {
679 return property_set_->name.value();
680 }
681
682 void set_name(const std::string& value,
683 const base::Callback<void(bool)>& callback) override {
684 property_set_->name.Set(value, callback);
685 }
686
687 private:
688 void OnPropertyChanged(const std::string& property_name) {
689 if (!on_property_changed_.is_null())
690 on_property_changed_.Run(this, property_name);
691 }
692
693 scoped_refptr<dbus::Bus> bus_;
694 std::string service_name_;
695 const dbus::ObjectPath object_path_{"/org/chromium/Test/Object"};
696 PropertySet* property_set_;
697 base::Callback<void(Itf1ProxyInterface*, const std::string&)> on_property_changed_;
698 dbus::ObjectProxy* dbus_object_proxy_;
699
700 friend class org::chromium::ObjectManagerProxy;
701 DISALLOW_COPY_AND_ASSIGN(Itf1Proxy);
702 };
703
704 } // namespace chromium
705 } // namespace org
706
707 namespace org {
708 namespace chromium {
709
710 // Abstract interface proxy for org::chromium::Itf2.
711 class Itf2ProxyInterface {
712 public:
713 virtual ~Itf2ProxyInterface() = default;
714
715 virtual const dbus::ObjectPath& GetObjectPath() const = 0;
716 };
717
718 } // namespace chromium
719 } // namespace org
720
721 namespace org {
722 namespace chromium {
723
724 // Interface proxy for org::chromium::Itf2.
725 class Itf2Proxy final : public Itf2ProxyInterface {
726 public:
727 class PropertySet : public dbus::PropertySet {
728 public:
729 PropertySet(dbus::ObjectProxy* object_proxy,
730 const PropertyChangedCallback& callback)
731 : dbus::PropertySet{object_proxy,
732 "org.chromium.Itf2",
733 callback} {
734 }
735
736
737 private:
738 DISALLOW_COPY_AND_ASSIGN(PropertySet);
739 };
740
741 Itf2Proxy(
742 const scoped_refptr<dbus::Bus>& bus,
743 const std::string& service_name,
744 const dbus::ObjectPath& object_path) :
745 bus_{bus},
746 service_name_{service_name},
747 object_path_{object_path},
748 dbus_object_proxy_{
749 bus_->GetObjectProxy(service_name_, object_path_)} {
750 }
751
752 ~Itf2Proxy() override {
753 }
754
755 void ReleaseObjectProxy(const base::Closure& callback) {
756 bus_->RemoveObjectProxy(service_name_, object_path_, callback);
757 }
758
759 const dbus::ObjectPath& GetObjectPath() const override {
760 return object_path_;
761 }
762
763 dbus::ObjectProxy* GetObjectProxy() const { return dbus_object_proxy_; }
764
765 private:
766 scoped_refptr<dbus::Bus> bus_;
767 std::string service_name_;
768 dbus::ObjectPath object_path_;
769 dbus::ObjectProxy* dbus_object_proxy_;
770
771 DISALLOW_COPY_AND_ASSIGN(Itf2Proxy);
772 };
773
774 } // namespace chromium
775 } // namespace org
776
777 namespace org {
778 namespace chromium {
779
780 class ObjectManagerProxy : public dbus::ObjectManager::Interface {
781 public:
782 ObjectManagerProxy(const scoped_refptr<dbus::Bus>& bus,
783 const std::string& service_name)
784 : bus_{bus},
785 service_name_{service_name},
786 dbus_object_manager_{bus->GetObjectManager(
787 service_name,
788 dbus::ObjectPath{"/org/chromium/Test"})} {
789 dbus_object_manager_->RegisterInterface("org.chromium.Itf1", this);
790 dbus_object_manager_->RegisterInterface("org.chromium.Itf2", this);
791 }
792
793 ~ObjectManagerProxy() override {
794 dbus_object_manager_->UnregisterInterface("org.chromium.Itf1");
795 dbus_object_manager_->UnregisterInterface("org.chromium.Itf2");
796 }
797
798 dbus::ObjectManager* GetObjectManagerProxy() const {
799 return dbus_object_manager_;
800 }
801
802 org::chromium::Itf1ProxyInterface* GetItf1Proxy() {
803 if (itf1_instances_.empty())
804 return nullptr;
805 return itf1_instances_.begin()->second.get();
806 }
807 std::vector<org::chromium::Itf1ProxyInterface*> GetItf1Instances() const {
808 std::vector<org::chromium::Itf1ProxyInterface*> values;
809 values.reserve(itf1_instances_.size());
810 for (const auto& pair : itf1_instances_)
811 values.push_back(pair.second.get());
812 return values;
813 }
814 void SetItf1AddedCallback(
815 const base::Callback<void(org::chromium::Itf1ProxyInterface*)>& callback) {
816 on_itf1_added_ = callback;
817 }
818 void SetItf1RemovedCallback(
819 const base::Callback<void(const dbus::ObjectPath&)>& callback) {
820 on_itf1_removed_ = callback;
821 }
822
823 org::chromium::Itf2ProxyInterface* GetItf2Proxy(
824 const dbus::ObjectPath& object_path) {
825 auto p = itf2_instances_.find(object_path);
826 if (p != itf2_instances_.end())
827 return p->second.get();
828 return nullptr;
829 }
830 std::vector<org::chromium::Itf2ProxyInterface*> GetItf2Instances() const {
831 std::vector<org::chromium::Itf2ProxyInterface*> values;
832 values.reserve(itf2_instances_.size());
833 for (const auto& pair : itf2_instances_)
834 values.push_back(pair.second.get());
835 return values;
836 }
837 void SetItf2AddedCallback(
838 const base::Callback<void(org::chromium::Itf2ProxyInterface*)>& callback) {
839 on_itf2_added_ = callback;
840 }
841 void SetItf2RemovedCallback(
842 const base::Callback<void(const dbus::ObjectPath&)>& callback) {
843 on_itf2_removed_ = callback;
844 }
845
846 private:
847 void OnPropertyChanged(const dbus::ObjectPath& object_path,
848 const std::string& interface_name,
849 const std::string& property_name) {
850 if (interface_name == "org.chromium.Itf1") {
851 auto p = itf1_instances_.find(object_path);
852 if (p == itf1_instances_.end())
853 return;
854 p->second->OnPropertyChanged(property_name);
855 return;
856 }
857 }
858
859 void ObjectAdded(
860 const dbus::ObjectPath& object_path,
861 const std::string& interface_name) override {
862 if (interface_name == "org.chromium.Itf1") {
863 auto property_set =
864 static_cast<org::chromium::Itf1Proxy::PropertySet*>(
865 dbus_object_manager_->GetProperties(object_path, interface_name));
866 std::unique_ptr<org::chromium::Itf1Proxy> itf1_proxy{
867 new org::chromium::Itf1Proxy{bus_, service_name_, property_set}
868 };
869 auto p = itf1_instances_.emplace(object_path, std::move(itf1_proxy));
870 if (!on_itf1_added_.is_null())
871 on_itf1_added_.Run(p.first->second.get());
872 return;
873 }
874 if (interface_name == "org.chromium.Itf2") {
875 std::unique_ptr<org::chromium::Itf2Proxy> itf2_proxy{
876 new org::chromium::Itf2Proxy{bus_, service_name_, object_path}
877 };
878 auto p = itf2_instances_.emplace(object_path, std::move(itf2_proxy));
879 if (!on_itf2_added_.is_null())
880 on_itf2_added_.Run(p.first->second.get());
881 return;
882 }
883 }
884
885 void ObjectRemoved(
886 const dbus::ObjectPath& object_path,
887 const std::string& interface_name) override {
888 if (interface_name == "org.chromium.Itf1") {
889 auto p = itf1_instances_.find(object_path);
890 if (p != itf1_instances_.end()) {
891 if (!on_itf1_removed_.is_null())
892 on_itf1_removed_.Run(object_path);
893 itf1_instances_.erase(p);
894 }
895 return;
896 }
897 if (interface_name == "org.chromium.Itf2") {
898 auto p = itf2_instances_.find(object_path);
899 if (p != itf2_instances_.end()) {
900 if (!on_itf2_removed_.is_null())
901 on_itf2_removed_.Run(object_path);
902 itf2_instances_.erase(p);
903 }
904 return;
905 }
906 }
907
908 dbus::PropertySet* CreateProperties(
909 dbus::ObjectProxy* object_proxy,
910 const dbus::ObjectPath& object_path,
911 const std::string& interface_name) override {
912 if (interface_name == "org.chromium.Itf1") {
913 return new org::chromium::Itf1Proxy::PropertySet{
914 object_proxy,
915 base::Bind(&ObjectManagerProxy::OnPropertyChanged,
916 weak_ptr_factory_.GetWeakPtr(),
917 object_path,
918 interface_name)
919 };
920 }
921 if (interface_name == "org.chromium.Itf2") {
922 return new org::chromium::Itf2Proxy::PropertySet{
923 object_proxy,
924 base::Bind(&ObjectManagerProxy::OnPropertyChanged,
925 weak_ptr_factory_.GetWeakPtr(),
926 object_path,
927 interface_name)
928 };
929 }
930 LOG(FATAL) << "Creating properties for unsupported interface "
931 << interface_name;
932 return nullptr;
933 }
934
935 scoped_refptr<dbus::Bus> bus_;
936 std::string service_name_;
937 dbus::ObjectManager* dbus_object_manager_;
938 std::map<dbus::ObjectPath,
939 std::unique_ptr<org::chromium::Itf1Proxy>> itf1_instances_;
940 base::Callback<void(org::chromium::Itf1ProxyInterface*)> on_itf1_added_;
941 base::Callback<void(const dbus::ObjectPath&)> on_itf1_removed_;
942 std::map<dbus::ObjectPath,
943 std::unique_ptr<org::chromium::Itf2Proxy>> itf2_instances_;
944 base::Callback<void(org::chromium::Itf2ProxyInterface*)> on_itf2_added_;
945 base::Callback<void(const dbus::ObjectPath&)> on_itf2_removed_;
946 base::WeakPtrFactory<ObjectManagerProxy> weak_ptr_factory_{this};
947
948 DISALLOW_COPY_AND_ASSIGN(ObjectManagerProxy);
949 };
950
951 } // namespace chromium
952 } // namespace org
953 )literal_string";
954
955 const char kExpectedContentWithObjectManagerAndServiceName[] = R"literal_string(
956 #include <memory>
957 #include <string>
958 #include <vector>
959
960 #include <base/bind.h>
961 #include <base/callback.h>
962 #include <base/logging.h>
963 #include <base/macros.h>
964 #include <base/memory/ref_counted.h>
965 #include <brillo/any.h>
966 #include <brillo/dbus/dbus_method_invoker.h>
967 #include <brillo/dbus/dbus_property.h>
968 #include <brillo/dbus/dbus_signal_handler.h>
969 #include <brillo/errors/error.h>
970 #include <brillo/variant_dictionary.h>
971 #include <dbus/bus.h>
972 #include <dbus/message.h>
973 #include <dbus/object_manager.h>
974 #include <dbus/object_path.h>
975 #include <dbus/object_proxy.h>
976
977 namespace org {
978 namespace chromium {
979 class ObjectManagerProxy;
980 } // namespace chromium
981 } // namespace org
982
983 namespace org {
984 namespace chromium {
985
986 // Abstract interface proxy for org::chromium::Itf1.
987 class Itf1ProxyInterface {
988 public:
989 virtual ~Itf1ProxyInterface() = default;
990
991 virtual void RegisterCloserSignalHandler(
992 const base::Closure& signal_callback,
993 dbus::ObjectProxy::OnConnectedCallback on_connected_callback) = 0;
994
995 virtual const dbus::ObjectPath& GetObjectPath() const = 0;
996 };
997
998 } // namespace chromium
999 } // namespace org
1000
1001 namespace org {
1002 namespace chromium {
1003
1004 // Interface proxy for org::chromium::Itf1.
1005 class Itf1Proxy final : public Itf1ProxyInterface {
1006 public:
1007 class PropertySet : public dbus::PropertySet {
1008 public:
1009 PropertySet(dbus::ObjectProxy* object_proxy,
1010 const PropertyChangedCallback& callback)
1011 : dbus::PropertySet{object_proxy,
1012 "org.chromium.Itf1",
1013 callback} {
1014 }
1015
1016
1017 private:
1018 DISALLOW_COPY_AND_ASSIGN(PropertySet);
1019 };
1020
1021 Itf1Proxy(const scoped_refptr<dbus::Bus>& bus) :
1022 bus_{bus},
1023 dbus_object_proxy_{
1024 bus_->GetObjectProxy(service_name_, object_path_)} {
1025 }
1026
1027 ~Itf1Proxy() override {
1028 }
1029
1030 void RegisterCloserSignalHandler(
1031 const base::Closure& signal_callback,
1032 dbus::ObjectProxy::OnConnectedCallback on_connected_callback) override {
1033 brillo::dbus_utils::ConnectToSignal(
1034 dbus_object_proxy_,
1035 "org.chromium.Itf1",
1036 "Closer",
1037 signal_callback,
1038 on_connected_callback);
1039 }
1040
1041 void ReleaseObjectProxy(const base::Closure& callback) {
1042 bus_->RemoveObjectProxy(service_name_, object_path_, callback);
1043 }
1044
1045 const dbus::ObjectPath& GetObjectPath() const override {
1046 return object_path_;
1047 }
1048
1049 dbus::ObjectProxy* GetObjectProxy() const { return dbus_object_proxy_; }
1050
1051 private:
1052 scoped_refptr<dbus::Bus> bus_;
1053 const std::string service_name_{"org.chromium.Test"};
1054 const dbus::ObjectPath object_path_{"/org/chromium/Test/Object"};
1055 dbus::ObjectProxy* dbus_object_proxy_;
1056
1057 DISALLOW_COPY_AND_ASSIGN(Itf1Proxy);
1058 };
1059
1060 } // namespace chromium
1061 } // namespace org
1062
1063 namespace org {
1064 namespace chromium {
1065
1066 // Abstract interface proxy for org::chromium::Itf2.
1067 class Itf2ProxyInterface {
1068 public:
1069 virtual ~Itf2ProxyInterface() = default;
1070
1071 virtual const dbus::ObjectPath& GetObjectPath() const = 0;
1072 };
1073
1074 } // namespace chromium
1075 } // namespace org
1076
1077 namespace org {
1078 namespace chromium {
1079
1080 // Interface proxy for org::chromium::Itf2.
1081 class Itf2Proxy final : public Itf2ProxyInterface {
1082 public:
1083 class PropertySet : public dbus::PropertySet {
1084 public:
1085 PropertySet(dbus::ObjectProxy* object_proxy,
1086 const PropertyChangedCallback& callback)
1087 : dbus::PropertySet{object_proxy,
1088 "org.chromium.Itf2",
1089 callback} {
1090 }
1091
1092
1093 private:
1094 DISALLOW_COPY_AND_ASSIGN(PropertySet);
1095 };
1096
1097 Itf2Proxy(
1098 const scoped_refptr<dbus::Bus>& bus,
1099 const dbus::ObjectPath& object_path) :
1100 bus_{bus},
1101 object_path_{object_path},
1102 dbus_object_proxy_{
1103 bus_->GetObjectProxy(service_name_, object_path_)} {
1104 }
1105
1106 ~Itf2Proxy() override {
1107 }
1108
1109 void ReleaseObjectProxy(const base::Closure& callback) {
1110 bus_->RemoveObjectProxy(service_name_, object_path_, callback);
1111 }
1112
1113 const dbus::ObjectPath& GetObjectPath() const override {
1114 return object_path_;
1115 }
1116
1117 dbus::ObjectProxy* GetObjectProxy() const { return dbus_object_proxy_; }
1118
1119 private:
1120 scoped_refptr<dbus::Bus> bus_;
1121 const std::string service_name_{"org.chromium.Test"};
1122 dbus::ObjectPath object_path_;
1123 dbus::ObjectProxy* dbus_object_proxy_;
1124
1125 DISALLOW_COPY_AND_ASSIGN(Itf2Proxy);
1126 };
1127
1128 } // namespace chromium
1129 } // namespace org
1130
1131 namespace org {
1132 namespace chromium {
1133
1134 class ObjectManagerProxy : public dbus::ObjectManager::Interface {
1135 public:
1136 ObjectManagerProxy(const scoped_refptr<dbus::Bus>& bus)
1137 : bus_{bus},
1138 dbus_object_manager_{bus->GetObjectManager(
1139 "org.chromium.Test",
1140 dbus::ObjectPath{"/org/chromium/Test"})} {
1141 dbus_object_manager_->RegisterInterface("org.chromium.Itf1", this);
1142 dbus_object_manager_->RegisterInterface("org.chromium.Itf2", this);
1143 }
1144
1145 ~ObjectManagerProxy() override {
1146 dbus_object_manager_->UnregisterInterface("org.chromium.Itf1");
1147 dbus_object_manager_->UnregisterInterface("org.chromium.Itf2");
1148 }
1149
1150 dbus::ObjectManager* GetObjectManagerProxy() const {
1151 return dbus_object_manager_;
1152 }
1153
1154 org::chromium::Itf1ProxyInterface* GetItf1Proxy() {
1155 if (itf1_instances_.empty())
1156 return nullptr;
1157 return itf1_instances_.begin()->second.get();
1158 }
1159 std::vector<org::chromium::Itf1ProxyInterface*> GetItf1Instances() const {
1160 std::vector<org::chromium::Itf1ProxyInterface*> values;
1161 values.reserve(itf1_instances_.size());
1162 for (const auto& pair : itf1_instances_)
1163 values.push_back(pair.second.get());
1164 return values;
1165 }
1166 void SetItf1AddedCallback(
1167 const base::Callback<void(org::chromium::Itf1ProxyInterface*)>& callback) {
1168 on_itf1_added_ = callback;
1169 }
1170 void SetItf1RemovedCallback(
1171 const base::Callback<void(const dbus::ObjectPath&)>& callback) {
1172 on_itf1_removed_ = callback;
1173 }
1174
1175 org::chromium::Itf2ProxyInterface* GetItf2Proxy(
1176 const dbus::ObjectPath& object_path) {
1177 auto p = itf2_instances_.find(object_path);
1178 if (p != itf2_instances_.end())
1179 return p->second.get();
1180 return nullptr;
1181 }
1182 std::vector<org::chromium::Itf2ProxyInterface*> GetItf2Instances() const {
1183 std::vector<org::chromium::Itf2ProxyInterface*> values;
1184 values.reserve(itf2_instances_.size());
1185 for (const auto& pair : itf2_instances_)
1186 values.push_back(pair.second.get());
1187 return values;
1188 }
1189 void SetItf2AddedCallback(
1190 const base::Callback<void(org::chromium::Itf2ProxyInterface*)>& callback) {
1191 on_itf2_added_ = callback;
1192 }
1193 void SetItf2RemovedCallback(
1194 const base::Callback<void(const dbus::ObjectPath&)>& callback) {
1195 on_itf2_removed_ = callback;
1196 }
1197
1198 private:
1199 void OnPropertyChanged(const dbus::ObjectPath& /* object_path */,
1200 const std::string& /* interface_name */,
1201 const std::string& /* property_name */) {}
1202
1203 void ObjectAdded(
1204 const dbus::ObjectPath& object_path,
1205 const std::string& interface_name) override {
1206 if (interface_name == "org.chromium.Itf1") {
1207 std::unique_ptr<org::chromium::Itf1Proxy> itf1_proxy{
1208 new org::chromium::Itf1Proxy{bus_}
1209 };
1210 auto p = itf1_instances_.emplace(object_path, std::move(itf1_proxy));
1211 if (!on_itf1_added_.is_null())
1212 on_itf1_added_.Run(p.first->second.get());
1213 return;
1214 }
1215 if (interface_name == "org.chromium.Itf2") {
1216 std::unique_ptr<org::chromium::Itf2Proxy> itf2_proxy{
1217 new org::chromium::Itf2Proxy{bus_, object_path}
1218 };
1219 auto p = itf2_instances_.emplace(object_path, std::move(itf2_proxy));
1220 if (!on_itf2_added_.is_null())
1221 on_itf2_added_.Run(p.first->second.get());
1222 return;
1223 }
1224 }
1225
1226 void ObjectRemoved(
1227 const dbus::ObjectPath& object_path,
1228 const std::string& interface_name) override {
1229 if (interface_name == "org.chromium.Itf1") {
1230 auto p = itf1_instances_.find(object_path);
1231 if (p != itf1_instances_.end()) {
1232 if (!on_itf1_removed_.is_null())
1233 on_itf1_removed_.Run(object_path);
1234 itf1_instances_.erase(p);
1235 }
1236 return;
1237 }
1238 if (interface_name == "org.chromium.Itf2") {
1239 auto p = itf2_instances_.find(object_path);
1240 if (p != itf2_instances_.end()) {
1241 if (!on_itf2_removed_.is_null())
1242 on_itf2_removed_.Run(object_path);
1243 itf2_instances_.erase(p);
1244 }
1245 return;
1246 }
1247 }
1248
1249 dbus::PropertySet* CreateProperties(
1250 dbus::ObjectProxy* object_proxy,
1251 const dbus::ObjectPath& object_path,
1252 const std::string& interface_name) override {
1253 if (interface_name == "org.chromium.Itf1") {
1254 return new org::chromium::Itf1Proxy::PropertySet{
1255 object_proxy,
1256 base::Bind(&ObjectManagerProxy::OnPropertyChanged,
1257 weak_ptr_factory_.GetWeakPtr(),
1258 object_path,
1259 interface_name)
1260 };
1261 }
1262 if (interface_name == "org.chromium.Itf2") {
1263 return new org::chromium::Itf2Proxy::PropertySet{
1264 object_proxy,
1265 base::Bind(&ObjectManagerProxy::OnPropertyChanged,
1266 weak_ptr_factory_.GetWeakPtr(),
1267 object_path,
1268 interface_name)
1269 };
1270 }
1271 LOG(FATAL) << "Creating properties for unsupported interface "
1272 << interface_name;
1273 return nullptr;
1274 }
1275
1276 scoped_refptr<dbus::Bus> bus_;
1277 dbus::ObjectManager* dbus_object_manager_;
1278 std::map<dbus::ObjectPath,
1279 std::unique_ptr<org::chromium::Itf1Proxy>> itf1_instances_;
1280 base::Callback<void(org::chromium::Itf1ProxyInterface*)> on_itf1_added_;
1281 base::Callback<void(const dbus::ObjectPath&)> on_itf1_removed_;
1282 std::map<dbus::ObjectPath,
1283 std::unique_ptr<org::chromium::Itf2Proxy>> itf2_instances_;
1284 base::Callback<void(org::chromium::Itf2ProxyInterface*)> on_itf2_added_;
1285 base::Callback<void(const dbus::ObjectPath&)> on_itf2_removed_;
1286 base::WeakPtrFactory<ObjectManagerProxy> weak_ptr_factory_{this};
1287
1288 DISALLOW_COPY_AND_ASSIGN(ObjectManagerProxy);
1289 };
1290
1291 } // namespace chromium
1292 } // namespace org
1293 )literal_string";
1294 } // namespace
1295
1296 class ProxyGeneratorTest : public Test {
1297 public:
SetUp()1298 void SetUp() override {
1299 ASSERT_TRUE(temp_dir_.CreateUniqueTempDir());
1300 }
1301
1302 protected:
CreateInputFile(const string & contents)1303 base::FilePath CreateInputFile(const string& contents) {
1304 base::FilePath path;
1305 EXPECT_TRUE(base::CreateTemporaryFileInDir(temp_dir_.path(), &path));
1306 int written = base::WriteFile(path, contents.c_str(), contents.size());
1307 EXPECT_EQ(contents.size(), static_cast<size_t>(written));
1308 return path;
1309 }
1310
1311 base::ScopedTempDir temp_dir_;
1312 };
1313
TEST_F(ProxyGeneratorTest,GenerateAdaptors)1314 TEST_F(ProxyGeneratorTest, GenerateAdaptors) {
1315 Interface interface;
1316 interface.name = "org.chromium.TestInterface";
1317 interface.path = "/org/chromium/Test";
1318 interface.methods.emplace_back(
1319 "Elements",
1320 vector<Interface::Argument>{
1321 {"space_walk", kDBusTypeString},
1322 {"ramblin_man", kDBusTypeArryOfObjects}},
1323 vector<Interface::Argument>{{"", kDBusTypeString}});
1324 interface.methods.emplace_back(
1325 "ReturnToPatagonia",
1326 vector<Interface::Argument>{},
1327 vector<Interface::Argument>{{"", kDBusTypeInt64}});
1328 interface.methods.emplace_back(
1329 "NiceWeatherForDucks",
1330 vector<Interface::Argument>{{"", kDBusTypeBool}},
1331 vector<Interface::Argument>{});
1332 interface.methods.emplace_back("ExperimentNumberSix");
1333 interface.signals.emplace_back("Closer");
1334 interface.signals.emplace_back(
1335 "TheCurseOfKaZar",
1336 vector<Interface::Argument>{
1337 {"", kDBusTypeArryOfStrings},
1338 {"", kDBusTypeByte}});
1339 interface.methods.back().doc_string = "Comment line1\nline2";
1340 Interface interface2;
1341 interface2.name = "org.chromium.TestInterface2";
1342 interface2.methods.emplace_back(
1343 "GetPersonInfo",
1344 vector<Interface::Argument>{},
1345 vector<Interface::Argument>{
1346 {"name", kDBusTypeString},
1347 {"age", kDBusTypeInt32}});
1348 vector<Interface> interfaces{interface, interface2};
1349 base::FilePath output_path = temp_dir_.path().Append("output.h");
1350 ServiceConfig config;
1351 EXPECT_TRUE(ProxyGenerator::GenerateProxies(config, interfaces, output_path));
1352 string contents;
1353 EXPECT_TRUE(base::ReadFileToString(output_path, &contents));
1354 // The header guards contain the (temporary) filename, so we search for
1355 // the content we need within the string.
1356 test_utils::EXPECT_TEXT_CONTAINED(kExpectedContent, contents);
1357 }
1358
TEST_F(ProxyGeneratorTest,GenerateAdaptorsWithServiceName)1359 TEST_F(ProxyGeneratorTest, GenerateAdaptorsWithServiceName) {
1360 Interface interface;
1361 interface.name = "org.chromium.TestInterface";
1362 interface.path = "/org/chromium/Test";
1363 interface.signals.emplace_back("Closer");
1364 Interface interface2;
1365 interface2.name = "org.chromium.TestInterface2";
1366 vector<Interface> interfaces{interface, interface2};
1367 base::FilePath output_path = temp_dir_.path().Append("output2.h");
1368 ServiceConfig config;
1369 config.service_name = "org.chromium.Test";
1370 EXPECT_TRUE(ProxyGenerator::GenerateProxies(config, interfaces, output_path));
1371 string contents;
1372 EXPECT_TRUE(base::ReadFileToString(output_path, &contents));
1373 // The header guards contain the (temporary) filename, so we search for
1374 // the content we need within the string.
1375 test_utils::EXPECT_TEXT_CONTAINED(kExpectedContentWithService, contents);
1376 }
1377
TEST_F(ProxyGeneratorTest,GenerateAdaptorsWithObjectManager)1378 TEST_F(ProxyGeneratorTest, GenerateAdaptorsWithObjectManager) {
1379 Interface interface;
1380 interface.name = "org.chromium.Itf1";
1381 interface.path = "/org/chromium/Test/Object";
1382 interface.signals.emplace_back("Closer");
1383 interface.properties.emplace_back("Data", "s", "read");
1384 interface.properties.emplace_back("Name", "s", "readwrite");
1385 Interface interface2;
1386 interface2.name = "org.chromium.Itf2";
1387 vector<Interface> interfaces{interface, interface2};
1388 base::FilePath output_path = temp_dir_.path().Append("output3.h");
1389 ServiceConfig config;
1390 config.object_manager.name = "org.chromium.ObjectManager";
1391 config.object_manager.object_path = "/org/chromium/Test";
1392 EXPECT_TRUE(ProxyGenerator::GenerateProxies(config, interfaces, output_path));
1393 string contents;
1394 EXPECT_TRUE(base::ReadFileToString(output_path, &contents));
1395 // The header guards contain the (temporary) filename, so we search for
1396 // the content we need within the string.
1397 test_utils::EXPECT_TEXT_CONTAINED(
1398 kExpectedContentWithObjectManager, contents);
1399 }
1400
TEST_F(ProxyGeneratorTest,GenerateAdaptorsWithObjectManagerAndServiceName)1401 TEST_F(ProxyGeneratorTest, GenerateAdaptorsWithObjectManagerAndServiceName) {
1402 Interface interface;
1403 interface.name = "org.chromium.Itf1";
1404 interface.path = "/org/chromium/Test/Object";
1405 interface.signals.emplace_back("Closer");
1406 Interface interface2;
1407 interface2.name = "org.chromium.Itf2";
1408 vector<Interface> interfaces{interface, interface2};
1409 base::FilePath output_path = temp_dir_.path().Append("output4.h");
1410 ServiceConfig config;
1411 config.service_name = "org.chromium.Test";
1412 config.object_manager.name = "org.chromium.ObjectManager";
1413 config.object_manager.object_path = "/org/chromium/Test";
1414 EXPECT_TRUE(ProxyGenerator::GenerateProxies(config, interfaces, output_path));
1415 string contents;
1416 EXPECT_TRUE(base::ReadFileToString(output_path, &contents));
1417 // The header guards contain the (temporary) filename, so we search for
1418 // the content we need within the string.
1419 test_utils::EXPECT_TEXT_CONTAINED(
1420 kExpectedContentWithObjectManagerAndServiceName, contents);
1421 }
1422
1423 } // namespace chromeos_dbus_bindings
1424