Home | History | Annotate | Download | only in chromeos-dbus-bindings 
      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 <utility>
      8 
      9 #include <base/files/file_path.h>
     10 #include <base/format_macros.h>
     11 #include <base/logging.h>
     12 #include <base/strings/stringprintf.h>
     13 #include <brillo/strings/string_utils.h>
     14 
     15 #include "chromeos-dbus-bindings/dbus_signature.h"
     16 #include "chromeos-dbus-bindings/indented_text.h"
     17 #include "chromeos-dbus-bindings/name_parser.h"
     18 
     19 using base::StringPrintf;
     20 using std::pair;
     21 using std::string;
     22 using std::vector;
     23 
     24 namespace chromeos_dbus_bindings {
     25 
     26 namespace {
     27 // Helper struct to encapsulate information about method call parameter during
     28 // code generation.
     29 struct ParamDef {
     30   ParamDef(const string& param_type, const string& param_name, bool param_ref)
     31       : type(param_type), name(param_name), is_const_ref(param_ref) {}
     32 
     33   string type;
     34   string name;
     35   bool is_const_ref;
     36 };
     37 
     38 string GetParamString(const ParamDef& param_def) {
     39   return StringPrintf(param_def.is_const_ref ? "const %s& %s" : "%s* %s",
     40                       param_def.type.c_str(), param_def.name.c_str());
     41 }
     42 }  // anonymous namespace
     43 
     44 // static
     45 bool ProxyGenerator::GenerateProxies(
     46     const ServiceConfig& config,
     47     const std::vector<Interface>& interfaces,
     48     const base::FilePath& output_file) {
     49   IndentedText text;
     50 
     51   text.AddLine("// Automatic generation of D-Bus interfaces:");
     52   for (const auto& interface : interfaces) {
     53     text.AddLine(StringPrintf("//  - %s", interface.name.c_str()));
     54   }
     55   string header_guard = GenerateHeaderGuard(output_file);
     56   text.AddLine(StringPrintf("#ifndef %s", header_guard.c_str()));
     57   text.AddLine(StringPrintf("#define %s", header_guard.c_str()));
     58   text.AddLine("#include <memory>");
     59   text.AddLine("#include <string>");
     60   text.AddLine("#include <vector>");
     61   text.AddBlankLine();
     62   text.AddLine("#include <base/bind.h>");
     63   text.AddLine("#include <base/callback.h>");
     64   text.AddLine("#include <base/logging.h>");
     65   text.AddLine("#include <base/macros.h>");
     66   text.AddLine("#include <base/memory/ref_counted.h>");
     67   text.AddLine("#include <brillo/any.h>");
     68   text.AddLine("#include <brillo/dbus/dbus_method_invoker.h>");
     69   text.AddLine("#include <brillo/dbus/dbus_property.h>");
     70   text.AddLine("#include <brillo/dbus/dbus_signal_handler.h>");
     71   text.AddLine("#include <brillo/errors/error.h>");
     72   text.AddLine("#include <brillo/variant_dictionary.h>");
     73   text.AddLine("#include <dbus/bus.h>");
     74   text.AddLine("#include <dbus/message.h>");
     75   text.AddLine("#include <dbus/object_manager.h>");
     76   text.AddLine("#include <dbus/object_path.h>");
     77   text.AddLine("#include <dbus/object_proxy.h>");
     78   text.AddBlankLine();
     79 
     80   if (!config.object_manager.name.empty()) {
     81     // Add forward-declaration for Object Manager proxy class.
     82     NameParser parser{config.object_manager.name};
     83     parser.AddOpenNamespaces(&text, false);
     84     text.AddLine(StringPrintf("class %s;",
     85                               parser.MakeProxyName(false).c_str()));
     86     parser.AddCloseNamespaces(&text, false);
     87     text.AddBlankLine();
     88   }
     89 
     90   for (const auto& interface : interfaces) {
     91     GenerateInterfaceProxyInterface(config, interface, &text);
     92     GenerateInterfaceProxy(config, interface, &text);
     93   }
     94 
     95   ObjectManager::GenerateProxy(config, interfaces, &text);
     96 
     97   text.AddLine(StringPrintf("#endif  // %s", header_guard.c_str()));
     98   return WriteTextToFile(output_file, text);
     99 }
    100 
    101 // static
    102 bool ProxyGenerator::GenerateMocks(const ServiceConfig& config,
    103                                    const std::vector<Interface>& interfaces,
    104                                    const base::FilePath& mock_file,
    105                                    const base::FilePath& proxy_file,
    106                                    bool use_literal_proxy_file) {
    107   IndentedText text;
    108 
    109   text.AddLine("// Automatic generation of D-Bus interface mock proxies for:");
    110   for (const auto& interface : interfaces) {
    111     text.AddLine(StringPrintf("//  - %s", interface.name.c_str()));
    112   }
    113   string header_guard = GenerateHeaderGuard(mock_file);
    114   text.AddLine(StringPrintf("#ifndef %s", header_guard.c_str()));
    115   text.AddLine(StringPrintf("#define %s", header_guard.c_str()));
    116   text.AddLine("#include <string>");
    117   text.AddLine("#include <vector>");
    118   text.AddBlankLine();
    119   text.AddLine("#include <base/callback_forward.h>");
    120   text.AddLine("#include <base/logging.h>");
    121   text.AddLine("#include <base/macros.h>");
    122   text.AddLine("#include <brillo/any.h>");
    123   text.AddLine("#include <brillo/errors/error.h>");
    124   text.AddLine("#include <brillo/variant_dictionary.h>");
    125   text.AddLine("#include <gmock/gmock.h>");
    126   text.AddBlankLine();
    127 
    128   if (!proxy_file.empty()) {
    129     // If we have a proxy header file, it would have the proxy interfaces we
    130     // need to base our mocks on, so we need to include that header file.
    131     base::FilePath relative_path;
    132     if (use_literal_proxy_file) {
    133       relative_path = proxy_file;
    134     } else {
    135       // Generate a relative path from |mock_file| to |proxy_file|.
    136 
    137       // First, get the path components for both source and destination paths.
    138       std::vector<base::FilePath::StringType> src_components;
    139       mock_file.DirName().GetComponents(&src_components);
    140       std::vector<base::FilePath::StringType> dest_components;
    141       proxy_file.DirName().GetComponents(&dest_components);
    142 
    143       // Find the common root.
    144 
    145       // I wish we had C++14 and its 4-parameter version of std::mismatch()...
    146       auto src_end = src_components.end();
    147       if (src_components.size() > dest_components.size())
    148         src_end = src_components.begin() + dest_components.size();
    149 
    150       auto mismatch_pair = std::mismatch(src_components.begin(), src_end,
    151                                          dest_components.begin());
    152 
    153       // For each remaining components in the |src_components|, generate the
    154       // parent directory references ("..").
    155       size_t src_count = std::distance(mismatch_pair.first,
    156                                        src_components.end());
    157       std::vector<base::FilePath::StringType> components{
    158           src_count, base::FilePath::kParentDirectory};
    159       // Append the remaining components from |dest_components|.
    160       components.insert(components.end(),
    161                         mismatch_pair.second, dest_components.end());
    162       // Finally, add the base name of the target file name.
    163       components.push_back(proxy_file.BaseName().value());
    164       // Now reconstruct the relative path.
    165       relative_path = base::FilePath{base::FilePath::kCurrentDirectory};
    166       for (const auto& component : components)
    167         relative_path = relative_path.Append(component);
    168     }
    169     text.AddLine(StringPrintf("#include \"%s\"",
    170                               relative_path.value().c_str()));
    171     text.AddBlankLine();
    172   }
    173 
    174   for (const auto& interface : interfaces) {
    175     // If we have no proxy file, we need the abstract interfaces generated here.
    176     if (proxy_file.empty())
    177       GenerateInterfaceProxyInterface(config, interface, &text);
    178     GenerateInterfaceMock(config, interface, &text);
    179   }
    180 
    181   text.AddLine(StringPrintf("#endif  // %s", header_guard.c_str()));
    182   return WriteTextToFile(mock_file, text);
    183 }
    184 
    185 // static
    186 void ProxyGenerator::GenerateInterfaceProxyInterface(
    187     const ServiceConfig& config,
    188     const Interface& interface,
    189     IndentedText* text) {
    190   NameParser parser{interface.name};
    191   string proxy_name = parser.MakeProxyName(false);
    192   string base_interface_name = proxy_name + "Interface";
    193 
    194   parser.AddOpenNamespaces(text, false);
    195   text->AddBlankLine();
    196 
    197   text->AddLine(StringPrintf("// Abstract interface proxy for %s.",
    198                              parser.MakeFullCppName().c_str()));
    199   text->AddComments(interface.doc_string);
    200   text->AddLine(StringPrintf("class %s {", base_interface_name.c_str()));
    201   text->AddLineWithOffset("public:", kScopeOffset);
    202   text->PushOffset(kBlockOffset);
    203   text->AddLine(
    204       StringPrintf("virtual ~%s() = default;", base_interface_name.c_str()));
    205 
    206   for (const auto& method : interface.methods) {
    207     AddMethodProxy(method, interface.name, true, text);
    208     AddAsyncMethodProxy(method, interface.name, true, text);
    209   }
    210   for (const auto& signal : interface.signals) {
    211     AddSignalHandlerRegistration(signal, interface.name, true, text);
    212   }
    213   AddProperties(config, interface, true, text);
    214   text->AddBlankLine();
    215   text->AddLine("virtual const dbus::ObjectPath& GetObjectPath() const = 0;");
    216   if (!config.object_manager.name.empty() && !interface.properties.empty())
    217     AddPropertyPublicMethods(proxy_name, true, text);
    218 
    219   text->PopOffset();
    220   text->AddLine("};");
    221   text->AddBlankLine();
    222 
    223   parser.AddCloseNamespaces(text, false);
    224   text->AddBlankLine();
    225 }
    226 
    227 // static
    228 void ProxyGenerator::GenerateInterfaceProxy(const ServiceConfig& config,
    229                                             const Interface& interface,
    230                                             IndentedText* text) {
    231   NameParser parser{interface.name};
    232   string proxy_name = parser.MakeProxyName(false);
    233   string base_interface_name = proxy_name + "Interface";
    234 
    235   parser.AddOpenNamespaces(text, false);
    236   text->AddBlankLine();
    237 
    238   text->AddLine(StringPrintf("// Interface proxy for %s.",
    239                              parser.MakeFullCppName().c_str()));
    240   text->AddComments(interface.doc_string);
    241   text->AddLine(StringPrintf("class %s final : public %s {",
    242                              proxy_name.c_str(), base_interface_name.c_str()));
    243   text->AddLineWithOffset("public:", kScopeOffset);
    244   text->PushOffset(kBlockOffset);
    245   AddPropertySet(config, interface, text);
    246   AddConstructor(config, interface, proxy_name, text);
    247   AddDestructor(proxy_name, text);
    248   for (const auto& signal : interface.signals) {
    249     AddSignalHandlerRegistration(signal, interface.name, false, text);
    250   }
    251   AddReleaseObjectProxy(text);
    252   AddGetObjectPath(text);
    253   AddGetObjectProxy(text);
    254   if (!config.object_manager.name.empty() && !interface.properties.empty())
    255     AddPropertyPublicMethods(proxy_name, false, text);
    256   for (const auto& method : interface.methods) {
    257     AddMethodProxy(method, interface.name, false, text);
    258     AddAsyncMethodProxy(method, interface.name, false, text);
    259   }
    260   AddProperties(config, interface, false, text);
    261 
    262   text->PopOffset();
    263   text->AddBlankLine();
    264   text->AddLineWithOffset("private:", kScopeOffset);
    265 
    266   text->PushOffset(kBlockOffset);
    267   if (!config.object_manager.name.empty() && !interface.properties.empty())
    268     AddOnPropertyChanged(text);
    269   text->AddLine("scoped_refptr<dbus::Bus> bus_;");
    270   if (config.service_name.empty()) {
    271     text->AddLine("std::string service_name_;");
    272   } else {
    273     text->AddLine(StringPrintf("const std::string service_name_{\"%s\"};",
    274                                config.service_name.c_str()));
    275   }
    276   if (interface.path.empty()) {
    277     text->AddLine("dbus::ObjectPath object_path_;");
    278   } else {
    279     text->AddLine(StringPrintf("const dbus::ObjectPath object_path_{\"%s\"};",
    280                                interface.path.c_str()));
    281   }
    282   if (!config.object_manager.name.empty() && !interface.properties.empty()) {
    283     text->AddLine("PropertySet* property_set_;");
    284     text->AddLine(
    285         StringPrintf("base::Callback<void(%sInterface*, const std::string&)> "
    286                      "on_property_changed_;",
    287                      proxy_name.c_str()));
    288   }
    289   text->AddLine("dbus::ObjectProxy* dbus_object_proxy_;");
    290   text->AddBlankLine();
    291 
    292   if (!config.object_manager.name.empty() && !interface.properties.empty()) {
    293     text->AddLine(StringPrintf(
    294         "friend class %s;",
    295         NameParser{config.object_manager.name}.MakeProxyName(true).c_str()));
    296   }
    297   text->AddLine(StringPrintf("DISALLOW_COPY_AND_ASSIGN(%s);",
    298                              proxy_name.c_str()));
    299   text->PopOffset();
    300   text->AddLine("};");
    301 
    302   text->AddBlankLine();
    303 
    304   parser.AddCloseNamespaces(text, false);
    305 
    306   text->AddBlankLine();
    307 }
    308 
    309 // static
    310 void ProxyGenerator::GenerateInterfaceMock(const ServiceConfig& config,
    311                                            const Interface& interface,
    312                                            IndentedText* text) {
    313   NameParser parser{interface.name};
    314   string proxy_name = parser.MakeProxyName(false);
    315   string base_interface_name = proxy_name + "Interface";
    316   string mock_name = proxy_name + "Mock";
    317 
    318   parser.AddOpenNamespaces(text, false);
    319   text->AddBlankLine();
    320 
    321   text->AddLine(StringPrintf("// Mock object for %s.",
    322                              base_interface_name.c_str()));
    323   text->AddLine(StringPrintf("class %s : public %s {",
    324                              mock_name.c_str(), base_interface_name.c_str()));
    325   text->AddLineWithOffset("public:", kScopeOffset);
    326   text->PushOffset(kBlockOffset);
    327   text->AddLine(StringPrintf("%s() = default;", mock_name.c_str()));
    328   text->AddBlankLine();
    329 
    330   for (const auto& method : interface.methods) {
    331     AddMethodMock(method, interface.name, text);
    332     AddAsyncMethodMock(method, interface.name, text);
    333   }
    334   for (const auto& signal : interface.signals) {
    335     AddSignalHandlerRegistrationMock(signal, text);
    336   }
    337 
    338   DbusSignature signature;
    339   for (const auto& prop : interface.properties) {
    340     string type;
    341     CHECK(signature.Parse(prop.type, &type));
    342     MakeConstReferenceIfNeeded(&type);
    343     string name = NameParser{prop.name}.MakeVariableName();
    344     text->AddLine(StringPrintf("MOCK_CONST_METHOD0(%s, %s());",
    345                                name.c_str(), type.c_str()));
    346     if (prop.access == "readwrite") {
    347       text->AddLine(StringPrintf("MOCK_METHOD2(set_%s, void(%s, "
    348                                  "const base::Callback<bool>&));",
    349                                  name.c_str(), type.c_str()));
    350     }
    351   }
    352   text->AddLine(
    353       "MOCK_CONST_METHOD0(GetObjectPath, const dbus::ObjectPath&());");
    354   if (!config.object_manager.name.empty() && !interface.properties.empty()) {
    355     text->AddLineAndPushOffsetTo(
    356         "MOCK_METHOD1(SetPropertyChangedCallback,", 1, '(');
    357     text->AddLine(StringPrintf(
    358         "void(const base::Callback<void(%sInterface*, const std::string&)>&));",
    359         proxy_name.c_str()));
    360     text->PopOffset();
    361   }
    362 
    363   text->PopOffset();
    364   text->AddBlankLine();
    365   text->AddLineWithOffset("private:", kScopeOffset);
    366   text->AddLineWithOffset(StringPrintf("DISALLOW_COPY_AND_ASSIGN(%s);",
    367                                        mock_name.c_str()),
    368                           kBlockOffset);
    369   text->AddLine("};");
    370 
    371   parser.AddCloseNamespaces(text, false);
    372   text->AddBlankLine();
    373 }
    374 
    375 // static
    376 void ProxyGenerator::AddConstructor(const ServiceConfig& config,
    377                                     const Interface& interface,
    378                                     const string& class_name,
    379                                     IndentedText* text) {
    380   IndentedText block;
    381   vector<ParamDef> args{{"scoped_refptr<dbus::Bus>", "bus", true}};
    382   if (config.service_name.empty())
    383     args.emplace_back("std::string", "service_name", true);
    384   if (interface.path.empty())
    385     args.emplace_back("dbus::ObjectPath", "object_path", true);
    386   if (!config.object_manager.name.empty() && !interface.properties.empty())
    387     args.emplace_back("PropertySet", "property_set", false);
    388 
    389   if (args.size() == 1) {
    390     block.AddLine(StringPrintf("%s(%s) :", class_name.c_str(),
    391                                GetParamString(args.front()).c_str()));
    392   } else {
    393     block.AddLine(StringPrintf("%s(", class_name.c_str()));
    394     block.PushOffset(kLineContinuationOffset);
    395     for (size_t i = 0; i < args.size() - 1; i++) {
    396       block.AddLine(StringPrintf("%s,", GetParamString(args[i]).c_str()));
    397     }
    398     block.AddLine(StringPrintf("%s) :", GetParamString(args.back()).c_str()));
    399   }
    400   block.PushOffset(kLineContinuationOffset);
    401   for (const auto& arg : args) {
    402     block.AddLine(StringPrintf("%s_{%s},", arg.name.c_str(),
    403                                arg.name.c_str()));
    404   }
    405   block.AddLine("dbus_object_proxy_{");
    406   block.AddLineWithOffset(
    407       "bus_->GetObjectProxy(service_name_, object_path_)} {",
    408       kLineContinuationOffset);
    409   block.PopOffset();
    410   if (args.size() > 1)
    411     block.PopOffset();
    412   block.AddLine("}");
    413   block.AddBlankLine();
    414   text->AddBlock(block);
    415 }
    416 
    417 // static
    418 void ProxyGenerator::AddDestructor(const string& class_name,
    419                                    IndentedText* text) {
    420   IndentedText block;
    421   block.AddLine(StringPrintf("~%s() override {", class_name.c_str()));
    422   block.AddLine("}");
    423   text->AddBlock(block);
    424 }
    425 
    426 // static
    427 void ProxyGenerator::AddReleaseObjectProxy(IndentedText* text) {
    428   text->AddBlankLine();
    429   text->AddLine("void ReleaseObjectProxy(const base::Closure& callback) {");
    430   text->AddLineWithOffset(
    431       "bus_->RemoveObjectProxy(service_name_, object_path_, callback);",
    432       kBlockOffset);
    433   text->AddLine("}");
    434 }
    435 
    436 // static
    437 void ProxyGenerator::AddGetObjectPath(IndentedText* text) {
    438   text->AddBlankLine();
    439   text->AddLine("const dbus::ObjectPath& GetObjectPath() const override {");
    440   text->AddLineWithOffset("return object_path_;", kBlockOffset);
    441   text->AddLine("}");
    442 }
    443 
    444 // static
    445 void ProxyGenerator::AddGetObjectProxy(IndentedText* text) {
    446   text->AddBlankLine();
    447   text->AddLine("dbus::ObjectProxy* GetObjectProxy() const { "
    448                 "return dbus_object_proxy_; }");
    449 }
    450 
    451 // static
    452 void ProxyGenerator::AddPropertyPublicMethods(const string& class_name,
    453                                               bool declaration_only,
    454                                               IndentedText* text) {
    455   text->AddBlankLine();
    456   text->AddLine(StringPrintf("%svoid SetPropertyChangedCallback(",
    457                              declaration_only ? "virtual " : ""));
    458   text->AddLineWithOffset(
    459       StringPrintf("const base::Callback<void(%sInterface*, "
    460                    "const std::string&)>& callback) %s",
    461                    class_name.c_str(),
    462                    declaration_only ? "= 0;" : "override {"),
    463       kLineContinuationOffset);
    464   if (!declaration_only) {
    465     text->AddLineWithOffset("on_property_changed_ = callback;", kBlockOffset);
    466     text->AddLine("}");
    467     text->AddBlankLine();
    468 
    469     text->AddLine(
    470         "const PropertySet* GetProperties() const { return property_set_; }");
    471     text->AddLine("PropertySet* GetProperties() { return property_set_; }");
    472   }
    473 }
    474 
    475 // static
    476 void ProxyGenerator::AddOnPropertyChanged(IndentedText* text) {
    477   text->AddLine("void OnPropertyChanged(const std::string& property_name) {");
    478   text->PushOffset(kBlockOffset);
    479   text->AddLine("if (!on_property_changed_.is_null())");
    480   text->PushOffset(kBlockOffset);
    481   text->AddLine("on_property_changed_.Run(this, property_name);");
    482   text->PopOffset();
    483   text->PopOffset();
    484   text->AddLine("}");
    485   text->AddBlankLine();
    486 }
    487 
    488 void ProxyGenerator::AddSignalHandlerRegistration(
    489       const Interface::Signal& signal,
    490       const string& interface_name,
    491       bool declaration_only,
    492       IndentedText* text) {
    493   IndentedText block;
    494   block.AddBlankLine();
    495   block.AddLine(StringPrintf("%svoid Register%sSignalHandler(",
    496                              declaration_only ? "virtual " : "",
    497                              signal.name.c_str()));
    498   block.PushOffset(kLineContinuationOffset);
    499   AddSignalCallbackArg(signal, false, &block);
    500   block.AddLine(StringPrintf(
    501       "dbus::ObjectProxy::OnConnectedCallback on_connected_callback)%s",
    502       declaration_only ? " = 0;" : " override {"));
    503   if (!declaration_only) {
    504     block.PopOffset();  // Method signature arguments
    505     block.PushOffset(kBlockOffset);
    506     block.AddLine("brillo::dbus_utils::ConnectToSignal(");
    507     block.PushOffset(kLineContinuationOffset);
    508     block.AddLine("dbus_object_proxy_,");
    509     block.AddLine(StringPrintf("\"%s\",", interface_name.c_str()));
    510     block.AddLine(StringPrintf("\"%s\",", signal.name.c_str()));
    511     block.AddLine("signal_callback,");
    512     block.AddLine("on_connected_callback);");
    513     block.PopOffset();  // Function call line continuation
    514     block.PopOffset();  // Method body
    515     block.AddLine("}");
    516   }
    517   text->AddBlock(block);
    518 }
    519 
    520 // static
    521 void ProxyGenerator::AddPropertySet(const ServiceConfig& config,
    522                                     const Interface& interface,
    523                                     IndentedText* text) {
    524   // Must have ObjectManager in order for property system to work correctly.
    525   if (config.object_manager.name.empty())
    526     return;
    527 
    528   IndentedText block;
    529   block.AddLine("class PropertySet : public dbus::PropertySet {");
    530   block.AddLineWithOffset("public:", kScopeOffset);
    531   block.PushOffset(kBlockOffset);
    532   block.AddLineAndPushOffsetTo("PropertySet(dbus::ObjectProxy* object_proxy,",
    533                                1, '(');
    534   block.AddLine("const PropertyChangedCallback& callback)");
    535   block.PopOffset();
    536   block.PushOffset(kLineContinuationOffset);
    537   block.AddLineAndPushOffsetTo(": dbus::PropertySet{object_proxy,", 1, '{');
    538   block.AddLine(StringPrintf("\"%s\",", interface.name.c_str()));
    539   block.AddLine("callback} {");
    540   block.PopOffset();
    541   block.PopOffset();
    542   block.PushOffset(kBlockOffset);
    543   for (const auto& prop : interface.properties) {
    544     block.AddLine(
    545         StringPrintf("RegisterProperty(%sName(), &%s);",
    546                      prop.name.c_str(),
    547                      NameParser{prop.name}.MakeVariableName().c_str()));
    548   }
    549   block.PopOffset();
    550   block.AddLine("}");
    551   block.AddBlankLine();
    552 
    553   DbusSignature signature;
    554   for (const auto& prop : interface.properties) {
    555     string type;
    556     CHECK(signature.Parse(prop.type, &type));
    557     block.AddLine(
    558         StringPrintf("brillo::dbus_utils::Property<%s> %s;",
    559                      type.c_str(),
    560                      NameParser{prop.name}.MakeVariableName().c_str()));
    561   }
    562   block.AddBlankLine();
    563 
    564   block.PopOffset();
    565   block.AddLineWithOffset("private:", kScopeOffset);
    566   block.AddLineWithOffset("DISALLOW_COPY_AND_ASSIGN(PropertySet);",
    567                           kBlockOffset);
    568   block.AddLine("};");
    569   block.AddBlankLine();
    570 
    571   text->AddBlock(block);
    572 }
    573 
    574 // static
    575 void ProxyGenerator::AddProperties(const ServiceConfig& config,
    576                                    const Interface& interface,
    577                                    bool declaration_only,
    578                                    IndentedText* text) {
    579   // Must have ObjectManager in order for property system to work correctly.
    580   if (config.object_manager.name.empty())
    581     return;
    582 
    583   if (declaration_only && !interface.properties.empty())
    584     text->AddBlankLine();
    585 
    586   DbusSignature signature;
    587   for (const auto& prop : interface.properties) {
    588     if (declaration_only) {
    589       text->AddLine(
    590           StringPrintf("static const char* %sName() { return \"%s\"; }",
    591                        prop.name.c_str(),
    592                        prop.name.c_str()));
    593     }
    594     string type;
    595     CHECK(signature.Parse(prop.type, &type));
    596     MakeConstReferenceIfNeeded(&type);
    597     string name = NameParser{prop.name}.MakeVariableName();
    598     if (!declaration_only)
    599       text->AddBlankLine();
    600     text->AddLine(
    601         StringPrintf("%s%s %s() const%s",
    602                      declaration_only ? "virtual " : "",
    603                      type.c_str(),
    604                      name.c_str(),
    605                      declaration_only ? " = 0;" : " override {"));
    606     if (!declaration_only) {
    607       text->AddLineWithOffset(
    608           StringPrintf("return property_set_->%s.value();", name.c_str()),
    609           kBlockOffset);
    610       text->AddLine("}");
    611     }
    612     if (prop.access == "readwrite") {
    613       if (!declaration_only)
    614         text->AddBlankLine();
    615       text->AddLineAndPushOffsetTo(
    616           StringPrintf("%svoid set_%s(%s value,",
    617                        declaration_only ? "virtual " : "",
    618                        name.c_str(),
    619                        type.c_str()),
    620           1, '(');
    621       text->AddLine(
    622           StringPrintf("const base::Callback<void(bool)>& callback)%s",
    623                        declaration_only ? " = 0;" : " override {"));
    624       text->PopOffset();
    625       if (!declaration_only) {
    626         text->AddLineWithOffset(
    627             StringPrintf("property_set_->%s.Set(value, callback);", name.c_str()),
    628             kBlockOffset);
    629         text->AddLine("}");
    630       }
    631     }
    632   }
    633 }
    634 
    635 // static
    636 void ProxyGenerator::AddMethodProxy(const Interface::Method& method,
    637                                     const string& interface_name,
    638                                     bool declaration_only,
    639                                     IndentedText* text) {
    640   IndentedText block;
    641   DbusSignature signature;
    642   block.AddBlankLine();
    643   block.AddComments(method.doc_string);
    644   block.AddLine(StringPrintf("%sbool %s(",
    645                              declaration_only ? "virtual " : "",
    646                              method.name.c_str()));
    647   block.PushOffset(kLineContinuationOffset);
    648   vector<string> argument_names;
    649   int argument_number = 0;
    650   for (const auto& argument : method.input_arguments) {
    651     string argument_type;
    652     CHECK(signature.Parse(argument.type, &argument_type));
    653     MakeConstReferenceIfNeeded(&argument_type);
    654     string argument_name = GetArgName("in", argument.name, ++argument_number);
    655     argument_names.push_back(argument_name);
    656     block.AddLine(StringPrintf(
    657         "%s %s,", argument_type.c_str(), argument_name.c_str()));
    658   }
    659   vector<string> out_param_names{"response.get()", "error"};
    660   for (const auto& argument : method.output_arguments) {
    661     string argument_type;
    662     CHECK(signature.Parse(argument.type, &argument_type));
    663     string argument_name = GetArgName("out", argument.name, ++argument_number);
    664     out_param_names.push_back(argument_name);
    665     block.AddLine(StringPrintf(
    666         "%s* %s,", argument_type.c_str(), argument_name.c_str()));
    667   }
    668   block.AddLine("brillo::ErrorPtr* error,");
    669   block.AddLine(
    670       StringPrintf("int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT)%s",
    671                    declaration_only ? " = 0;" : " override {"));
    672   block.PopOffset();
    673   if (!declaration_only) {
    674     block.PushOffset(kBlockOffset);
    675 
    676     block.AddLine(
    677         "auto response = brillo::dbus_utils::CallMethodAndBlockWithTimeout(");
    678     block.PushOffset(kLineContinuationOffset);
    679     block.AddLine("timeout_ms,");
    680     block.AddLine("dbus_object_proxy_,");
    681     block.AddLine(StringPrintf("\"%s\",", interface_name.c_str()));
    682     block.AddLine(StringPrintf("\"%s\",", method.name.c_str()));
    683     string last_argument = "error";
    684     for (const auto& argument_name : argument_names) {
    685       block.AddLine(StringPrintf("%s,", last_argument.c_str()));
    686       last_argument = argument_name;
    687     }
    688     block.AddLine(StringPrintf("%s);", last_argument.c_str()));
    689     block.PopOffset();
    690 
    691     block.AddLine("return response && "
    692                   "brillo::dbus_utils::ExtractMethodCallResults(");
    693     block.PushOffset(kLineContinuationOffset);
    694     block.AddLine(brillo::string_utils::Join(", ", out_param_names) + ");");
    695     block.PopOffset();
    696     block.PopOffset();
    697     block.AddLine("}");
    698   }
    699   text->AddBlock(block);
    700 }
    701 
    702 // static
    703 void ProxyGenerator::AddAsyncMethodProxy(const Interface::Method& method,
    704                                          const string& interface_name,
    705                                          bool declaration_only,
    706                                          IndentedText* text) {
    707   IndentedText block;
    708   DbusSignature signature;
    709   block.AddBlankLine();
    710   block.AddComments(method.doc_string);
    711   block.AddLine(StringPrintf("%svoid %sAsync(",
    712                              declaration_only ? "virtual " : "",
    713                              method.name.c_str()));
    714   block.PushOffset(kLineContinuationOffset);
    715   vector<string> argument_names;
    716   int argument_number = 0;
    717   for (const auto& argument : method.input_arguments) {
    718     string argument_type;
    719     CHECK(signature.Parse(argument.type, &argument_type));
    720     MakeConstReferenceIfNeeded(&argument_type);
    721     string argument_name = GetArgName("in", argument.name, ++argument_number);
    722     argument_names.push_back(argument_name);
    723     block.AddLine(StringPrintf(
    724         "%s %s,", argument_type.c_str(), argument_name.c_str()));
    725   }
    726   vector<string> out_params;
    727   for (const auto& argument : method.output_arguments) {
    728     string argument_type;
    729     CHECK(signature.Parse(argument.type, &argument_type));
    730     MakeConstReferenceIfNeeded(&argument_type);
    731     if (!argument.name.empty())
    732       base::StringAppendF(&argument_type, " /*%s*/", argument.name.c_str());
    733     out_params.push_back(argument_type);
    734   }
    735   block.AddLine(StringPrintf(
    736       "const base::Callback<void(%s)>& success_callback,",
    737       brillo::string_utils::Join(", ", out_params).c_str()));
    738   block.AddLine(
    739       "const base::Callback<void(brillo::Error*)>& error_callback,");
    740   block.AddLine(
    741       StringPrintf("int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT)%s",
    742                    declaration_only ? " = 0;" : " override {"));
    743   block.PopOffset();
    744   if (!declaration_only) {
    745     block.PushOffset(kBlockOffset);
    746 
    747     block.AddLine("brillo::dbus_utils::CallMethodWithTimeout(");
    748     block.PushOffset(kLineContinuationOffset);
    749     block.AddLine("timeout_ms,");
    750     block.AddLine("dbus_object_proxy_,");
    751     block.AddLine(StringPrintf("\"%s\",", interface_name.c_str()));
    752     block.AddLine(StringPrintf("\"%s\",", method.name.c_str()));
    753     block.AddLine("success_callback,");
    754     string last_argument = "error_callback";
    755     for (const auto& argument_name : argument_names) {
    756       block.AddLine(StringPrintf("%s,", last_argument.c_str()));
    757       last_argument = argument_name;
    758     }
    759     block.AddLine(StringPrintf("%s);", last_argument.c_str()));
    760     block.PopOffset();
    761 
    762     block.PopOffset();
    763     block.AddLine("}");
    764   }
    765   text->AddBlock(block);
    766 }
    767 
    768 // static
    769 void ProxyGenerator::AddMethodMock(const Interface::Method& method,
    770                                    const string& /* interface_name */,
    771                                    IndentedText* text) {
    772   DbusSignature signature;
    773   vector<string> arguments;
    774   for (const auto& argument : method.input_arguments) {
    775     string argument_type;
    776     CHECK(signature.Parse(argument.type, &argument_type));
    777     MakeConstReferenceIfNeeded(&argument_type);
    778     if (!argument.name.empty())
    779       base::StringAppendF(&argument_type, " /*in_%s*/", argument.name.c_str());
    780     arguments.push_back(argument_type);
    781   }
    782   for (const auto& argument : method.output_arguments) {
    783     string argument_type;
    784     CHECK(signature.Parse(argument.type, &argument_type));
    785     argument_type += '*';
    786     if (!argument.name.empty())
    787       base::StringAppendF(&argument_type, " /*out_%s*/", argument.name.c_str());
    788     arguments.push_back(argument_type);
    789   }
    790   arguments.push_back("brillo::ErrorPtr* /*error*/");
    791   arguments.push_back("int /*timeout_ms*/");
    792   AddMockMethodDeclaration(method.name, "bool", arguments, text);
    793 }
    794 
    795 // static
    796 void ProxyGenerator::AddAsyncMethodMock(const Interface::Method& method,
    797                                         const string& /* interface_name */,
    798                                         IndentedText* text) {
    799   DbusSignature signature;
    800   vector<string> arguments;
    801   for (const auto& argument : method.input_arguments) {
    802     string argument_type;
    803     CHECK(signature.Parse(argument.type, &argument_type));
    804     MakeConstReferenceIfNeeded(&argument_type);
    805     if (!argument.name.empty())
    806       base::StringAppendF(&argument_type, " /*in_%s*/", argument.name.c_str());
    807     arguments.push_back(argument_type);
    808   }
    809   vector<string> out_params;
    810   for (const auto& argument : method.output_arguments) {
    811     string argument_type;
    812     CHECK(signature.Parse(argument.type, &argument_type));
    813     MakeConstReferenceIfNeeded(&argument_type);
    814     if (!argument.name.empty())
    815       base::StringAppendF(&argument_type, " /*%s*/", argument.name.c_str());
    816     out_params.push_back(argument_type);
    817   }
    818   arguments.push_back(StringPrintf(
    819       "const base::Callback<void(%s)>& /*success_callback*/",
    820       brillo::string_utils::Join(", ", out_params).c_str()));
    821   arguments.push_back(
    822       "const base::Callback<void(brillo::Error*)>& /*error_callback*/");
    823   arguments.push_back("int /*timeout_ms*/");
    824   AddMockMethodDeclaration(method.name + "Async", "void", arguments, text);
    825 }
    826 
    827 void ProxyGenerator::AddMockMethodDeclaration(const string& method_name,
    828                                               const string& return_type,
    829                                               const vector<string>& arguments,
    830                                               IndentedText* text) {
    831   IndentedText block;
    832   // GMOCK doesn't go all the way up to 11, so we need to handle methods with
    833   // 11 arguments or more in a different way.
    834   if (arguments.size() >= 11) {
    835     block.AddLineAndPushOffsetTo(
    836         StringPrintf("%s %s(%s,",
    837                      return_type.c_str(),
    838                      method_name.c_str(),
    839                      arguments.front().c_str()),
    840         1, '(');
    841     for (size_t i = 1; i < arguments.size() - 1; i++)
    842       block.AddLine(StringPrintf("%s,", arguments[i].c_str()));
    843     block.AddLine(StringPrintf("%s) override {", arguments.back().c_str()));
    844     block.PopOffset();
    845     block.PushOffset(kBlockOffset);
    846     block.AddLine(StringPrintf(
    847         "LOG(WARNING) << \"%s(): gmock can't handle methods with %" PRIuS
    848         " arguments. You can override this method in a subclass if you need"
    849         " to.\";",
    850         method_name.c_str(), arguments.size()));
    851     if (return_type == "void") {
    852       // No return added here.
    853     } else if (return_type == "bool") {
    854       block.AddLine("return false;");
    855     } else {
    856       LOG(FATAL) << "The return type is not supported.";
    857     }
    858     block.PopOffset();
    859     block.AddLine("}");
    860   } else {
    861     block.AddLineAndPushOffsetTo(
    862         StringPrintf("MOCK_METHOD%zu(%s,",
    863                      arguments.size(), method_name.c_str()),
    864         1, '(');
    865     block.AddLineAndPushOffsetTo(
    866         StringPrintf("%s(%s,", return_type.c_str(), arguments.front().c_str()),
    867         1, '(');
    868     for (size_t i = 1; i < arguments.size() - 1; i++)
    869       block.AddLine(StringPrintf("%s,", arguments[i].c_str()));
    870     block.AddLine(StringPrintf("%s));", arguments.back().c_str()));
    871     block.PopOffset();
    872     block.PopOffset();
    873   }
    874   text->AddBlock(block);
    875 }
    876 
    877 // static
    878 void ProxyGenerator::AddSignalHandlerRegistrationMock(
    879     const Interface::Signal& signal,
    880     IndentedText* text) {
    881   IndentedText callback_arg_text;
    882   AddSignalCallbackArg(signal, true, &callback_arg_text);
    883   vector<string> arg_lines = callback_arg_text.GetLines();
    884 
    885   IndentedText block;
    886   block.AddLineAndPushOffsetTo(
    887       StringPrintf("MOCK_METHOD2(Register%sSignalHandler,",
    888                    signal.name.c_str()),
    889       1, '(');
    890   for (size_t i = 0; i < arg_lines.size(); ++i) {
    891     if (i == 0)
    892       block.AddLineAndPushOffsetTo("void(" + arg_lines[i], 1, '(');
    893     else
    894       block.AddLine(arg_lines[i]);
    895   }
    896   block.AddLine(
    897       "dbus::ObjectProxy::OnConnectedCallback /*on_connected_callback*/));");
    898   text->AddBlock(block);
    899 }
    900 
    901 // static
    902 void ProxyGenerator::AddSignalCallbackArg(const Interface::Signal& signal,
    903                                           bool comment_arg_name,
    904                                           IndentedText* block) {
    905   DbusSignature signature;
    906   string signal_callback = StringPrintf("%ssignal_callback%s",
    907                                         comment_arg_name ? "/*" : "",
    908                                         comment_arg_name ? "*/" : "");
    909   if (signal.arguments.empty()) {
    910     block->AddLine(StringPrintf("const base::Closure& %s,",
    911                                 signal_callback.c_str()));
    912   } else {
    913     string last_argument;
    914     string prefix{"const base::Callback<void("};
    915     for (const auto argument : signal.arguments) {
    916       if (!last_argument.empty()) {
    917         if (!prefix.empty()) {
    918           block->AddLineAndPushOffsetTo(
    919               StringPrintf("%s%s,", prefix.c_str(), last_argument.c_str()),
    920               1, '(');
    921           prefix.clear();
    922         } else {
    923           block->AddLine(StringPrintf("%s,", last_argument.c_str()));
    924         }
    925       }
    926       CHECK(signature.Parse(argument.type, &last_argument));
    927       MakeConstReferenceIfNeeded(&last_argument);
    928     }
    929     block->AddLine(StringPrintf("%s%s)>& %s,",
    930                                 prefix.c_str(),
    931                                 last_argument.c_str(),
    932                                 signal_callback.c_str()));
    933     if (prefix.empty()) {
    934       block->PopOffset();
    935     }
    936   }
    937 }
    938 
    939 // static
    940 void ProxyGenerator::ObjectManager::GenerateProxy(
    941     const ServiceConfig& config,
    942     const std::vector<Interface>& interfaces,
    943     IndentedText* text) {
    944   if (config.object_manager.name.empty())
    945     return;
    946 
    947   NameParser object_manager{config.object_manager.name};
    948   object_manager.AddOpenNamespaces(text, false);
    949   text->AddBlankLine();
    950 
    951   string class_name = object_manager.type_name + "Proxy";
    952   text->AddLine(StringPrintf("class %s : "
    953                              "public dbus::ObjectManager::Interface {",
    954                              class_name.c_str()));
    955   text->AddLineWithOffset("public:", kScopeOffset);
    956   text->PushOffset(kBlockOffset);
    957 
    958   AddConstructor(config, class_name, interfaces, text);
    959   AddDestructor(class_name, interfaces, text);
    960   AddGetObjectManagerProxy(text);
    961   for (const auto& itf : interfaces) {
    962     AddInterfaceAccessors(itf, text);
    963   }
    964   text->PopOffset();
    965 
    966   text->AddLineWithOffset("private:", kScopeOffset);
    967   text->PushOffset(kBlockOffset);
    968   AddOnPropertyChanged(interfaces, text);
    969   AddObjectAdded(config, interfaces, text);
    970   AddObjectRemoved(interfaces, text);
    971   AddCreateProperties(interfaces, class_name, text);
    972   AddDataMembers(config, interfaces, class_name, text);
    973 
    974   text->AddLine(StringPrintf("DISALLOW_COPY_AND_ASSIGN(%s);",
    975                               class_name.c_str()));
    976   text->PopOffset();
    977   text->AddLine("};");
    978   text->AddBlankLine();
    979   object_manager.AddCloseNamespaces(text, false);
    980   text->AddBlankLine();
    981 }
    982 
    983 void ProxyGenerator::ObjectManager::AddConstructor(
    984     const ServiceConfig& config,
    985     const std::string& class_name,
    986     const std::vector<Interface>& interfaces,
    987     IndentedText* text) {
    988   if (config.service_name.empty()) {
    989     text->AddLineAndPushOffsetTo(
    990         StringPrintf("%s(const scoped_refptr<dbus::Bus>& bus,",
    991                      class_name.c_str()),
    992         1, '(');
    993     text->AddLine("const std::string& service_name)");
    994     text->PopOffset();
    995   } else {
    996     text->AddLine(StringPrintf("%s(const scoped_refptr<dbus::Bus>& bus)",
    997                                class_name.c_str()));
    998   }
    999   text->PushOffset(kLineContinuationOffset);
   1000   text->AddLine(": bus_{bus},");
   1001   text->PushOffset(kBlockOffset);
   1002   if (config.service_name.empty()) {
   1003     text->AddLine("service_name_{service_name},");
   1004   }
   1005   text->AddLine("dbus_object_manager_{bus->GetObjectManager(");
   1006   text->PushOffset(kLineContinuationOffset);
   1007   if (config.service_name.empty()) {
   1008     text->AddLine("service_name,");
   1009   } else {
   1010     text->AddLine(StringPrintf("\"%s\",", config.service_name.c_str()));
   1011   }
   1012   text->AddLine(StringPrintf("dbus::ObjectPath{\"%s\"})} {",
   1013                              config.object_manager.object_path.c_str()));
   1014   text->PopOffset();
   1015   text->PopOffset();
   1016   text->PopOffset();
   1017   text->PushOffset(kBlockOffset);
   1018   for (const auto& itf : interfaces) {
   1019     text->AddLine(
   1020         StringPrintf("dbus_object_manager_->RegisterInterface(\"%s\", this);",
   1021                      itf.name.c_str()));
   1022   }
   1023   text->PopOffset();
   1024   text->AddLine("}");
   1025   text->AddBlankLine();
   1026 }
   1027 
   1028 void ProxyGenerator::ObjectManager::AddDestructor(
   1029     const std::string& class_name,
   1030     const std::vector<Interface>& interfaces,
   1031     IndentedText* text) {
   1032   text->AddLine(StringPrintf("~%s() override {", class_name.c_str()));
   1033   text->PushOffset(kBlockOffset);
   1034   for (const auto& itf : interfaces) {
   1035     text->AddLine(
   1036         StringPrintf("dbus_object_manager_->UnregisterInterface(\"%s\");",
   1037                      itf.name.c_str()));
   1038   }
   1039   text->PopOffset();
   1040   text->AddLine("}");
   1041   text->AddBlankLine();
   1042 }
   1043 
   1044 void ProxyGenerator::ObjectManager::AddGetObjectManagerProxy(
   1045     IndentedText* text) {
   1046   text->AddLine("dbus::ObjectManager* GetObjectManagerProxy() const {");
   1047   text->AddLineWithOffset("return dbus_object_manager_;", kBlockOffset);
   1048   text->AddLine("}");
   1049   text->AddBlankLine();
   1050 }
   1051 
   1052 void ProxyGenerator::ObjectManager::AddInterfaceAccessors(
   1053     const Interface& interface,
   1054     IndentedText* text) {
   1055   NameParser itf_name{interface.name};
   1056   string map_name = itf_name.MakeVariableName() + "_instances_";
   1057 
   1058   // GetProxy().
   1059   if (interface.path.empty()) {
   1060     // We have no fixed path, so there could be multiple instances of this itf.
   1061     text->AddLine(StringPrintf("%sInterface* Get%s(",
   1062                                 itf_name.MakeProxyName(true).c_str(),
   1063                                 itf_name.MakeProxyName(false).c_str()));
   1064     text->PushOffset(kLineContinuationOffset);
   1065     text->AddLine("const dbus::ObjectPath& object_path) {");
   1066     text->PopOffset();
   1067     text->PushOffset(kBlockOffset);
   1068     text->AddLine(StringPrintf("auto p = %s.find(object_path);",
   1069                                 map_name.c_str()));
   1070     text->AddLine(StringPrintf("if (p != %s.end())", map_name.c_str()));
   1071     text->PushOffset(kBlockOffset);
   1072     text->AddLine("return p->second.get();");
   1073     text->PopOffset();
   1074     text->AddLine("return nullptr;");
   1075     text->PopOffset();
   1076     text->AddLine("}");
   1077   } else {
   1078     // We have a fixed path, so the object could be considered a "singleton".
   1079     // Skip the object_path parameter and return the first available instance.
   1080     text->AddLine(StringPrintf("%sInterface* Get%s() {",
   1081                                 itf_name.MakeProxyName(true).c_str(),
   1082                                 itf_name.MakeProxyName(false).c_str()));
   1083     text->PushOffset(kBlockOffset);
   1084     text->AddLine(StringPrintf("if (%s.empty())", map_name.c_str()));
   1085     text->AddLineWithOffset("return nullptr;", kBlockOffset);
   1086     text->AddLine(StringPrintf("return %s.begin()->second.get();",
   1087                                map_name.c_str()));
   1088     text->PopOffset();
   1089     text->AddLine("}");
   1090   }
   1091 
   1092   // GetInstances().
   1093   text->AddLine(
   1094       StringPrintf("std::vector<%sInterface*> Get%sInstances() const {",
   1095                    itf_name.MakeProxyName(true).c_str(),
   1096                    itf_name.type_name.c_str()));
   1097   text->PushOffset(kBlockOffset);
   1098   text->AddLine(StringPrintf("std::vector<%sInterface*> values;",
   1099                              itf_name.MakeProxyName(true).c_str()));
   1100   text->AddLine(StringPrintf("values.reserve(%s.size());", map_name.c_str()));
   1101   text->AddLine(StringPrintf("for (const auto& pair : %s)", map_name.c_str()));
   1102   text->AddLineWithOffset("values.push_back(pair.second.get());", kBlockOffset);
   1103   text->AddLine("return values;");
   1104   text->PopOffset();
   1105   text->AddLine("}");
   1106 
   1107   // SetAddedCallback().
   1108   text->AddLine(StringPrintf("void Set%sAddedCallback(",
   1109                               itf_name.type_name.c_str()));
   1110   text->PushOffset(kLineContinuationOffset);
   1111   text->AddLine(
   1112       StringPrintf("const base::Callback<void(%sInterface*)>& callback) {",
   1113                    itf_name.MakeProxyName(true).c_str()));
   1114   text->PopOffset();
   1115   text->PushOffset(kBlockOffset);
   1116   text->AddLine(StringPrintf("on_%s_added_ = callback;",
   1117                              itf_name.MakeVariableName().c_str()));
   1118   text->PopOffset();
   1119   text->AddLine("}");
   1120 
   1121   // SetRemovedCallback().
   1122   text->AddLine(StringPrintf("void Set%sRemovedCallback(",
   1123                              itf_name.type_name.c_str()));
   1124   text->PushOffset(kLineContinuationOffset);
   1125   text->AddLine("const base::Callback<void(const dbus::ObjectPath&)>& "
   1126                 "callback) {");
   1127   text->PopOffset();
   1128   text->PushOffset(kBlockOffset);
   1129   text->AddLine(StringPrintf("on_%s_removed_ = callback;",
   1130                               itf_name.MakeVariableName().c_str()));
   1131   text->PopOffset();
   1132   text->AddLine("}");
   1133 
   1134   text->AddBlankLine();
   1135 }
   1136 
   1137 void ProxyGenerator::ObjectManager::AddOnPropertyChanged(
   1138     const std::vector<Interface>& interfaces,
   1139     IndentedText* text) {
   1140   // If there are no interfaces with properties, comment out parameter
   1141   // names for OnPropertyChanged() to prevent compiler warnings on unused
   1142   // function parameters.
   1143   auto has_props = [](const Interface& itf) { return !itf.properties.empty(); };
   1144   auto itf_with_props = std::find_if(interfaces.begin(), interfaces.end(),
   1145                                      has_props);
   1146   if (itf_with_props == interfaces.end()) {
   1147     text->AddLineAndPushOffsetTo("void OnPropertyChanged("
   1148                                  "const dbus::ObjectPath& /* object_path */,",
   1149                                  1, '(');
   1150     text->AddLine("const std::string& /* interface_name */,");
   1151     text->AddLine("const std::string& /* property_name */) {}");
   1152     text->PopOffset();
   1153     text->AddBlankLine();
   1154     return;
   1155   }
   1156   text->AddLineAndPushOffsetTo("void OnPropertyChanged("
   1157                                "const dbus::ObjectPath& object_path,",
   1158                                1, '(');
   1159   text->AddLine("const std::string& interface_name,");
   1160   text->AddLine("const std::string& property_name) {");
   1161   text->PopOffset();
   1162   text->PushOffset(kBlockOffset);
   1163   for (const auto& itf : interfaces) {
   1164     if (itf.properties.empty())
   1165       continue;
   1166 
   1167     NameParser itf_name{itf.name};
   1168     text->AddLine(StringPrintf("if (interface_name == \"%s\") {",
   1169                                itf.name.c_str()));
   1170     text->PushOffset(kBlockOffset);
   1171     string map_name = itf_name.MakeVariableName() + "_instances_";
   1172     text->AddLine(StringPrintf("auto p = %s.find(object_path);",
   1173                                map_name.c_str()));
   1174     text->AddLine(StringPrintf("if (p == %s.end())", map_name.c_str()));
   1175     text->PushOffset(kBlockOffset);
   1176     text->AddLine("return;");
   1177     text->PopOffset();
   1178     text->AddLine("p->second->OnPropertyChanged(property_name);");
   1179     text->AddLine("return;");
   1180     text->PopOffset();
   1181     text->AddLine("}");
   1182   }
   1183   text->PopOffset();
   1184   text->AddLine("}");
   1185   text->AddBlankLine();
   1186 }
   1187 
   1188 void ProxyGenerator::ObjectManager::AddObjectAdded(
   1189     const ServiceConfig& config,
   1190     const std::vector<Interface>& interfaces,
   1191     IndentedText* text) {
   1192   text->AddLine("void ObjectAdded(");
   1193   text->PushOffset(kLineContinuationOffset);
   1194   text->AddLine("const dbus::ObjectPath& object_path,");
   1195   text->AddLine("const std::string& interface_name) override {");
   1196   text->PopOffset();
   1197   text->PushOffset(kBlockOffset);
   1198   for (const auto& itf : interfaces) {
   1199     NameParser itf_name{itf.name};
   1200     string var_name = itf_name.MakeVariableName();
   1201     text->AddLine(StringPrintf("if (interface_name == \"%s\") {",
   1202                                itf.name.c_str()));
   1203     text->PushOffset(kBlockOffset);
   1204     if (!itf.properties.empty()) {
   1205       text->AddLine("auto property_set =");
   1206       text->PushOffset(kLineContinuationOffset);
   1207       text->AddLine(StringPrintf("static_cast<%s::PropertySet*>(",
   1208                                  itf_name.MakeProxyName(true).c_str()));
   1209       text->PushOffset(kLineContinuationOffset);
   1210       text->AddLine("dbus_object_manager_->GetProperties(object_path, "
   1211                     "interface_name));");
   1212       text->PopOffset();
   1213       text->PopOffset();
   1214     }
   1215     text->AddLine(StringPrintf("std::unique_ptr<%s> %s_proxy{",
   1216                                itf_name.MakeProxyName(true).c_str(),
   1217                                var_name.c_str()));
   1218     text->PushOffset(kBlockOffset);
   1219     string new_instance = StringPrintf("new %s{bus_",
   1220                                        itf_name.MakeProxyName(true).c_str());
   1221     if (config.service_name.empty()) {
   1222       new_instance += ", service_name_";
   1223     }
   1224     if (itf.path.empty())
   1225       new_instance += ", object_path";
   1226     if (!itf.properties.empty())
   1227       new_instance += ", property_set";
   1228     new_instance += "}";
   1229     text->AddLine(new_instance);
   1230     text->PopOffset();
   1231     text->AddLine("};");
   1232     text->AddLine(StringPrintf("auto p = %s_instances_.emplace(object_path, "
   1233                                "std::move(%s_proxy));",
   1234                                var_name.c_str(), var_name.c_str()));
   1235     text->AddLine(StringPrintf("if (!on_%s_added_.is_null())",
   1236                                var_name.c_str()));
   1237     text->PushOffset(kBlockOffset);
   1238     text->AddLine(StringPrintf("on_%s_added_.Run(p.first->second.get());",
   1239                                var_name.c_str()));
   1240     text->PopOffset();
   1241     text->AddLine("return;");
   1242     text->PopOffset();
   1243     text->AddLine("}");
   1244   }
   1245   text->PopOffset();
   1246   text->AddLine("}");
   1247   text->AddBlankLine();
   1248 }
   1249 
   1250 void ProxyGenerator::ObjectManager::AddObjectRemoved(
   1251     const std::vector<Interface>& interfaces,
   1252     IndentedText* text) {
   1253   text->AddLine("void ObjectRemoved(");
   1254   text->PushOffset(kLineContinuationOffset);
   1255   text->AddLine("const dbus::ObjectPath& object_path,");
   1256   text->AddLine("const std::string& interface_name) override {");
   1257   text->PopOffset();
   1258   text->PushOffset(kBlockOffset);
   1259   for (const auto& itf : interfaces) {
   1260     NameParser itf_name{itf.name};
   1261     string var_name = itf_name.MakeVariableName();
   1262     text->AddLine(StringPrintf("if (interface_name == \"%s\") {",
   1263                                itf.name.c_str()));
   1264     text->PushOffset(kBlockOffset);
   1265     text->AddLine(StringPrintf("auto p = %s_instances_.find(object_path);",
   1266                                var_name.c_str()));
   1267     text->AddLine(StringPrintf("if (p != %s_instances_.end()) {",
   1268                                var_name.c_str()));
   1269     text->PushOffset(kBlockOffset);
   1270     text->AddLine(StringPrintf("if (!on_%s_removed_.is_null())",
   1271                                var_name.c_str()));
   1272     text->PushOffset(kBlockOffset);
   1273     text->AddLine(StringPrintf("on_%s_removed_.Run(object_path);",
   1274                                var_name.c_str()));
   1275     text->PopOffset();
   1276     text->AddLine(StringPrintf("%s_instances_.erase(p);",
   1277                                var_name.c_str()));
   1278     text->PopOffset();
   1279     text->AddLine("}");
   1280     text->AddLine("return;");
   1281     text->PopOffset();
   1282     text->AddLine("}");
   1283   }
   1284   text->PopOffset();
   1285   text->AddLine("}");
   1286   text->AddBlankLine();
   1287 }
   1288 
   1289 void ProxyGenerator::ObjectManager::AddCreateProperties(
   1290     const std::vector<Interface>& interfaces,
   1291     const std::string& class_name,
   1292     IndentedText* text) {
   1293   text->AddLine("dbus::PropertySet* CreateProperties(");
   1294   text->PushOffset(kLineContinuationOffset);
   1295   text->AddLine("dbus::ObjectProxy* object_proxy,");
   1296   text->AddLine("const dbus::ObjectPath& object_path,");
   1297   text->AddLine("const std::string& interface_name) override {");
   1298   text->PopOffset();
   1299   text->PushOffset(kBlockOffset);
   1300   for (const auto& itf : interfaces) {
   1301     NameParser itf_name{itf.name};
   1302     text->AddLine(StringPrintf("if (interface_name == \"%s\") {",
   1303                                itf.name.c_str()));
   1304     text->PushOffset(kBlockOffset);
   1305     text->AddLine(StringPrintf("return new %s::PropertySet{",
   1306                                itf_name.MakeProxyName(true).c_str()));
   1307     text->PushOffset(kLineContinuationOffset);
   1308     text->AddLine("object_proxy,");
   1309     text->AddLineAndPushOffsetTo(
   1310         StringPrintf("base::Bind(&%s::OnPropertyChanged,",
   1311                      class_name.c_str()),
   1312         1, '(');
   1313     text->AddLine("weak_ptr_factory_.GetWeakPtr(),");
   1314     text->AddLine("object_path,");
   1315     text->AddLine("interface_name)");
   1316     text->PopOffset();
   1317     text->PopOffset();
   1318     text->AddLine("};");
   1319     text->PopOffset();
   1320     text->AddLine("}");
   1321   }
   1322   text->AddLineAndPushOffsetTo("LOG(FATAL) << \"Creating properties for "
   1323                                "unsupported interface \"", 1, ' ');
   1324   text->AddLine("<< interface_name;");
   1325   text->PopOffset();
   1326   text->AddLine("return nullptr;");
   1327   text->PopOffset();
   1328   text->AddLine("}");
   1329   text->AddBlankLine();
   1330 }
   1331 
   1332 void ProxyGenerator::ObjectManager::AddDataMembers(
   1333     const ServiceConfig& config,
   1334     const std::vector<Interface>& interfaces,
   1335     const std::string& class_name,
   1336     IndentedText* text) {
   1337   text->AddLine("scoped_refptr<dbus::Bus> bus_;");
   1338   if (config.service_name.empty()) {
   1339     text->AddLine("std::string service_name_;");
   1340   }
   1341   text->AddLine("dbus::ObjectManager* dbus_object_manager_;");
   1342   for (const auto& itf : interfaces) {
   1343     NameParser itf_name{itf.name};
   1344     string var_name = itf_name.MakeVariableName();
   1345     text->AddLineAndPushOffsetTo("std::map<dbus::ObjectPath,", 1, '<');
   1346     text->AddLine(StringPrintf("std::unique_ptr<%s>> %s_instances_;",
   1347                                itf_name.MakeProxyName(true).c_str(),
   1348                                var_name.c_str()));
   1349     text->PopOffset();
   1350     text->AddLine(
   1351         StringPrintf("base::Callback<void(%sInterface*)> on_%s_added_;",
   1352                      itf_name.MakeProxyName(true).c_str(),
   1353                      var_name.c_str()));
   1354     text->AddLine(StringPrintf("base::Callback<void(const dbus::ObjectPath&)> "
   1355                                "on_%s_removed_;",
   1356                                var_name.c_str()));
   1357   }
   1358   text->AddLine(
   1359       StringPrintf("base::WeakPtrFactory<%s> weak_ptr_factory_{this};",
   1360                    class_name.c_str()));
   1361   text->AddBlankLine();
   1362 }
   1363 
   1364 // static
   1365 string ProxyGenerator::GetHandlerNameForSignal(const string& signal) {
   1366   return StringPrintf("On%sSignal", signal.c_str());
   1367 }
   1368 
   1369 }  // namespace chromeos_dbus_bindings
   1370