Home | History | Annotate | Download | only in shill
      1 // Automatic generation of D-Bus interface mock proxies for:
      2 //  - org.chromium.flimflam.Manager
      3 //  - org.chromium.flimflam.Service
      4 #ifndef ____CHROMEOS_DBUS_BINDING___UPDATE_ENGINE_INCLUDE_SHILL_DBUS_PROXY_MOCKS_H
      5 #define ____CHROMEOS_DBUS_BINDING___UPDATE_ENGINE_INCLUDE_SHILL_DBUS_PROXY_MOCKS_H
      6 #include <string>
      7 #include <vector>
      8 
      9 #include <base/callback_forward.h>
     10 #include <base/logging.h>
     11 #include <base/macros.h>
     12 #include <brillo/any.h>
     13 #include <brillo/errors/error.h>
     14 #include <brillo/variant_dictionary.h>
     15 #include <gmock/gmock.h>
     16 
     17 #include "shill/dbus-proxies.h"
     18 
     19 namespace org {
     20 namespace chromium {
     21 namespace flimflam {
     22 
     23 // Mock object for ManagerProxyInterface.
     24 class ManagerProxyMock : public ManagerProxyInterface {
     25  public:
     26   ManagerProxyMock() = default;
     27 
     28   MOCK_METHOD3(GetProperties,
     29                bool(brillo::VariantDictionary*,
     30                     brillo::ErrorPtr* /*error*/,
     31                     int /*timeout_ms*/));
     32   MOCK_METHOD3(GetPropertiesAsync,
     33                void(const base::Callback<void(const brillo::VariantDictionary&)>& /*success_callback*/,
     34                     const base::Callback<void(brillo::Error*)>& /*error_callback*/,
     35                     int /*timeout_ms*/));
     36   MOCK_METHOD4(SetProperty,
     37                bool(const std::string&,
     38                     const brillo::Any&,
     39                     brillo::ErrorPtr* /*error*/,
     40                     int /*timeout_ms*/));
     41   MOCK_METHOD5(SetPropertyAsync,
     42                void(const std::string&,
     43                     const brillo::Any&,
     44                     const base::Callback<void()>& /*success_callback*/,
     45                     const base::Callback<void(brillo::Error*)>& /*error_callback*/,
     46                     int /*timeout_ms*/));
     47   MOCK_METHOD3(GetState,
     48                bool(std::string*,
     49                     brillo::ErrorPtr* /*error*/,
     50                     int /*timeout_ms*/));
     51   MOCK_METHOD3(GetStateAsync,
     52                void(const base::Callback<void(const std::string&)>& /*success_callback*/,
     53                     const base::Callback<void(brillo::Error*)>& /*error_callback*/,
     54                     int /*timeout_ms*/));
     55   MOCK_METHOD4(CreateProfile,
     56                bool(const std::string&,
     57                     dbus::ObjectPath*,
     58                     brillo::ErrorPtr* /*error*/,
     59                     int /*timeout_ms*/));
     60   MOCK_METHOD4(CreateProfileAsync,
     61                void(const std::string&,
     62                     const base::Callback<void(const dbus::ObjectPath&)>& /*success_callback*/,
     63                     const base::Callback<void(brillo::Error*)>& /*error_callback*/,
     64                     int /*timeout_ms*/));
     65   MOCK_METHOD3(RemoveProfile,
     66                bool(const std::string&,
     67                     brillo::ErrorPtr* /*error*/,
     68                     int /*timeout_ms*/));
     69   MOCK_METHOD4(RemoveProfileAsync,
     70                void(const std::string&,
     71                     const base::Callback<void()>& /*success_callback*/,
     72                     const base::Callback<void(brillo::Error*)>& /*error_callback*/,
     73                     int /*timeout_ms*/));
     74   MOCK_METHOD4(PushProfile,
     75                bool(const std::string&,
     76                     dbus::ObjectPath*,
     77                     brillo::ErrorPtr* /*error*/,
     78                     int /*timeout_ms*/));
     79   MOCK_METHOD4(PushProfileAsync,
     80                void(const std::string&,
     81                     const base::Callback<void(const dbus::ObjectPath&)>& /*success_callback*/,
     82                     const base::Callback<void(brillo::Error*)>& /*error_callback*/,
     83                     int /*timeout_ms*/));
     84   MOCK_METHOD5(InsertUserProfile,
     85                bool(const std::string&,
     86                     const std::string&,
     87                     dbus::ObjectPath*,
     88                     brillo::ErrorPtr* /*error*/,
     89                     int /*timeout_ms*/));
     90   MOCK_METHOD5(InsertUserProfileAsync,
     91                void(const std::string&,
     92                     const std::string&,
     93                     const base::Callback<void(const dbus::ObjectPath&)>& /*success_callback*/,
     94                     const base::Callback<void(brillo::Error*)>& /*error_callback*/,
     95                     int /*timeout_ms*/));
     96   MOCK_METHOD3(PopProfile,
     97                bool(const std::string&,
     98                     brillo::ErrorPtr* /*error*/,
     99                     int /*timeout_ms*/));
    100   MOCK_METHOD4(PopProfileAsync,
    101                void(const std::string&,
    102                     const base::Callback<void()>& /*success_callback*/,
    103                     const base::Callback<void(brillo::Error*)>& /*error_callback*/,
    104                     int /*timeout_ms*/));
    105   MOCK_METHOD2(PopAnyProfile,
    106                bool(brillo::ErrorPtr* /*error*/,
    107                     int /*timeout_ms*/));
    108   MOCK_METHOD3(PopAnyProfileAsync,
    109                void(const base::Callback<void()>& /*success_callback*/,
    110                     const base::Callback<void(brillo::Error*)>& /*error_callback*/,
    111                     int /*timeout_ms*/));
    112   MOCK_METHOD2(PopAllUserProfiles,
    113                bool(brillo::ErrorPtr* /*error*/,
    114                     int /*timeout_ms*/));
    115   MOCK_METHOD3(PopAllUserProfilesAsync,
    116                void(const base::Callback<void()>& /*success_callback*/,
    117                     const base::Callback<void(brillo::Error*)>& /*error_callback*/,
    118                     int /*timeout_ms*/));
    119   MOCK_METHOD2(RecheckPortal,
    120                bool(brillo::ErrorPtr* /*error*/,
    121                     int /*timeout_ms*/));
    122   MOCK_METHOD3(RecheckPortalAsync,
    123                void(const base::Callback<void()>& /*success_callback*/,
    124                     const base::Callback<void(brillo::Error*)>& /*error_callback*/,
    125                     int /*timeout_ms*/));
    126   MOCK_METHOD3(RequestScan,
    127                bool(const std::string&,
    128                     brillo::ErrorPtr* /*error*/,
    129                     int /*timeout_ms*/));
    130   MOCK_METHOD4(RequestScanAsync,
    131                void(const std::string&,
    132                     const base::Callback<void()>& /*success_callback*/,
    133                     const base::Callback<void(brillo::Error*)>& /*error_callback*/,
    134                     int /*timeout_ms*/));
    135   MOCK_METHOD3(EnableTechnology,
    136                bool(const std::string&,
    137                     brillo::ErrorPtr* /*error*/,
    138                     int /*timeout_ms*/));
    139   MOCK_METHOD4(EnableTechnologyAsync,
    140                void(const std::string&,
    141                     const base::Callback<void()>& /*success_callback*/,
    142                     const base::Callback<void(brillo::Error*)>& /*error_callback*/,
    143                     int /*timeout_ms*/));
    144   MOCK_METHOD3(DisableTechnology,
    145                bool(const std::string&,
    146                     brillo::ErrorPtr* /*error*/,
    147                     int /*timeout_ms*/));
    148   MOCK_METHOD4(DisableTechnologyAsync,
    149                void(const std::string&,
    150                     const base::Callback<void()>& /*success_callback*/,
    151                     const base::Callback<void(brillo::Error*)>& /*error_callback*/,
    152                     int /*timeout_ms*/));
    153   MOCK_METHOD4(GetService,
    154                bool(const brillo::VariantDictionary&,
    155                     dbus::ObjectPath*,
    156                     brillo::ErrorPtr* /*error*/,
    157                     int /*timeout_ms*/));
    158   MOCK_METHOD4(GetServiceAsync,
    159                void(const brillo::VariantDictionary&,
    160                     const base::Callback<void(const dbus::ObjectPath&)>& /*success_callback*/,
    161                     const base::Callback<void(brillo::Error*)>& /*error_callback*/,
    162                     int /*timeout_ms*/));
    163   MOCK_METHOD4(GetWifiService,
    164                bool(const brillo::VariantDictionary&,
    165                     dbus::ObjectPath*,
    166                     brillo::ErrorPtr* /*error*/,
    167                     int /*timeout_ms*/));
    168   MOCK_METHOD4(GetWifiServiceAsync,
    169                void(const brillo::VariantDictionary&,
    170                     const base::Callback<void(const dbus::ObjectPath&)>& /*success_callback*/,
    171                     const base::Callback<void(brillo::Error*)>& /*error_callback*/,
    172                     int /*timeout_ms*/));
    173   MOCK_METHOD4(ConfigureService,
    174                bool(const brillo::VariantDictionary&,
    175                     dbus::ObjectPath*,
    176                     brillo::ErrorPtr* /*error*/,
    177                     int /*timeout_ms*/));
    178   MOCK_METHOD4(ConfigureServiceAsync,
    179                void(const brillo::VariantDictionary&,
    180                     const base::Callback<void(const dbus::ObjectPath&)>& /*success_callback*/,
    181                     const base::Callback<void(brillo::Error*)>& /*error_callback*/,
    182                     int /*timeout_ms*/));
    183   MOCK_METHOD5(ConfigureServiceForProfile,
    184                bool(const dbus::ObjectPath&,
    185                     const brillo::VariantDictionary&,
    186                     dbus::ObjectPath*,
    187                     brillo::ErrorPtr* /*error*/,
    188                     int /*timeout_ms*/));
    189   MOCK_METHOD5(ConfigureServiceForProfileAsync,
    190                void(const dbus::ObjectPath&,
    191                     const brillo::VariantDictionary&,
    192                     const base::Callback<void(const dbus::ObjectPath&)>& /*success_callback*/,
    193                     const base::Callback<void(brillo::Error*)>& /*error_callback*/,
    194                     int /*timeout_ms*/));
    195   MOCK_METHOD4(FindMatchingService,
    196                bool(const brillo::VariantDictionary&,
    197                     dbus::ObjectPath*,
    198                     brillo::ErrorPtr* /*error*/,
    199                     int /*timeout_ms*/));
    200   MOCK_METHOD4(FindMatchingServiceAsync,
    201                void(const brillo::VariantDictionary&,
    202                     const base::Callback<void(const dbus::ObjectPath&)>& /*success_callback*/,
    203                     const base::Callback<void(brillo::Error*)>& /*error_callback*/,
    204                     int /*timeout_ms*/));
    205   MOCK_METHOD4(GetVPNService,
    206                bool(const brillo::VariantDictionary&,
    207                     dbus::ObjectPath*,
    208                     brillo::ErrorPtr* /*error*/,
    209                     int /*timeout_ms*/));
    210   MOCK_METHOD4(GetVPNServiceAsync,
    211                void(const brillo::VariantDictionary&,
    212                     const base::Callback<void(const dbus::ObjectPath&)>& /*success_callback*/,
    213                     const base::Callback<void(brillo::Error*)>& /*error_callback*/,
    214                     int /*timeout_ms*/));
    215   MOCK_METHOD3(GetDebugLevel,
    216                bool(int32_t*,
    217                     brillo::ErrorPtr* /*error*/,
    218                     int /*timeout_ms*/));
    219   MOCK_METHOD3(GetDebugLevelAsync,
    220                void(const base::Callback<void(int32_t)>& /*success_callback*/,
    221                     const base::Callback<void(brillo::Error*)>& /*error_callback*/,
    222                     int /*timeout_ms*/));
    223   MOCK_METHOD3(SetDebugLevel,
    224                bool(int32_t,
    225                     brillo::ErrorPtr* /*error*/,
    226                     int /*timeout_ms*/));
    227   MOCK_METHOD4(SetDebugLevelAsync,
    228                void(int32_t,
    229                     const base::Callback<void()>& /*success_callback*/,
    230                     const base::Callback<void(brillo::Error*)>& /*error_callback*/,
    231                     int /*timeout_ms*/));
    232   MOCK_METHOD3(GetServiceOrder,
    233                bool(std::string*,
    234                     brillo::ErrorPtr* /*error*/,
    235                     int /*timeout_ms*/));
    236   MOCK_METHOD3(GetServiceOrderAsync,
    237                void(const base::Callback<void(const std::string&)>& /*success_callback*/,
    238                     const base::Callback<void(brillo::Error*)>& /*error_callback*/,
    239                     int /*timeout_ms*/));
    240   MOCK_METHOD3(SetServiceOrder,
    241                bool(const std::string&,
    242                     brillo::ErrorPtr* /*error*/,
    243                     int /*timeout_ms*/));
    244   MOCK_METHOD4(SetServiceOrderAsync,
    245                void(const std::string&,
    246                     const base::Callback<void()>& /*success_callback*/,
    247                     const base::Callback<void(brillo::Error*)>& /*error_callback*/,
    248                     int /*timeout_ms*/));
    249   MOCK_METHOD3(GetDebugTags,
    250                bool(std::string*,
    251                     brillo::ErrorPtr* /*error*/,
    252                     int /*timeout_ms*/));
    253   MOCK_METHOD3(GetDebugTagsAsync,
    254                void(const base::Callback<void(const std::string&)>& /*success_callback*/,
    255                     const base::Callback<void(brillo::Error*)>& /*error_callback*/,
    256                     int /*timeout_ms*/));
    257   MOCK_METHOD3(SetDebugTags,
    258                bool(const std::string&,
    259                     brillo::ErrorPtr* /*error*/,
    260                     int /*timeout_ms*/));
    261   MOCK_METHOD4(SetDebugTagsAsync,
    262                void(const std::string&,
    263                     const base::Callback<void()>& /*success_callback*/,
    264                     const base::Callback<void(brillo::Error*)>& /*error_callback*/,
    265                     int /*timeout_ms*/));
    266   MOCK_METHOD3(ListDebugTags,
    267                bool(std::string*,
    268                     brillo::ErrorPtr* /*error*/,
    269                     int /*timeout_ms*/));
    270   MOCK_METHOD3(ListDebugTagsAsync,
    271                void(const base::Callback<void(const std::string&)>& /*success_callback*/,
    272                     const base::Callback<void(brillo::Error*)>& /*error_callback*/,
    273                     int /*timeout_ms*/));
    274   MOCK_METHOD3(GetNetworksForGeolocation,
    275                bool(brillo::VariantDictionary*,
    276                     brillo::ErrorPtr* /*error*/,
    277                     int /*timeout_ms*/));
    278   MOCK_METHOD3(GetNetworksForGeolocationAsync,
    279                void(const base::Callback<void(const brillo::VariantDictionary&)>& /*success_callback*/,
    280                     const base::Callback<void(brillo::Error*)>& /*error_callback*/,
    281                     int /*timeout_ms*/));
    282   MOCK_METHOD10(VerifyDestination,
    283                 bool(const std::string& /*in_certificate*/,
    284                      const std::string& /*in_public_key*/,
    285                      const std::string& /*in_nonce*/,
    286                      const std::string& /*in_signed_data*/,
    287                      const std::string& /*in_destination_udn*/,
    288                      const std::string& /*in_hotspot_ssid*/,
    289                      const std::string& /*in_hotspot_bssid*/,
    290                      bool*,
    291                      brillo::ErrorPtr* /*error*/,
    292                      int /*timeout_ms*/));
    293   MOCK_METHOD10(VerifyDestinationAsync,
    294                 void(const std::string& /*in_certificate*/,
    295                      const std::string& /*in_public_key*/,
    296                      const std::string& /*in_nonce*/,
    297                      const std::string& /*in_signed_data*/,
    298                      const std::string& /*in_destination_udn*/,
    299                      const std::string& /*in_hotspot_ssid*/,
    300                      const std::string& /*in_hotspot_bssid*/,
    301                      const base::Callback<void(bool)>& /*success_callback*/,
    302                      const base::Callback<void(brillo::Error*)>& /*error_callback*/,
    303                      int /*timeout_ms*/));
    304   bool VerifyAndEncryptCredentials(const std::string& /*in_certificate*/,
    305                                    const std::string& /*in_public_key*/,
    306                                    const std::string& /*in_nonce*/,
    307                                    const std::string& /*in_signed_data*/,
    308                                    const std::string& /*in_destination_udn*/,
    309                                    const std::string& /*in_hotspot_ssid*/,
    310                                    const std::string& /*in_hotspot_bssid*/,
    311                                    const dbus::ObjectPath& /*in_network*/,
    312                                    std::string*,
    313                                    brillo::ErrorPtr* /*error*/,
    314                                    int /*timeout_ms*/) override {
    315     LOG(WARNING) << "VerifyAndEncryptCredentials(): gmock can't handle methods with 11 arguments. You can override this method in a subclass if you need to.";
    316     return false;
    317   }
    318   void VerifyAndEncryptCredentialsAsync(const std::string& /*in_certificate*/,
    319                                         const std::string& /*in_public_key*/,
    320                                         const std::string& /*in_nonce*/,
    321                                         const std::string& /*in_signed_data*/,
    322                                         const std::string& /*in_destination_udn*/,
    323                                         const std::string& /*in_hotspot_ssid*/,
    324                                         const std::string& /*in_hotspot_bssid*/,
    325                                         const dbus::ObjectPath& /*in_network*/,
    326                                         const base::Callback<void(const std::string&)>& /*success_callback*/,
    327                                         const base::Callback<void(brillo::Error*)>& /*error_callback*/,
    328                                         int /*timeout_ms*/) override {
    329     LOG(WARNING) << "VerifyAndEncryptCredentialsAsync(): gmock can't handle methods with 11 arguments. You can override this method in a subclass if you need to.";
    330   }
    331   bool VerifyAndEncryptData(const std::string& /*in_certificate*/,
    332                             const std::string& /*in_public_key*/,
    333                             const std::string& /*in_nonce*/,
    334                             const std::string& /*in_signed_data*/,
    335                             const std::string& /*in_destination_udn*/,
    336                             const std::string& /*in_hotspot_ssid*/,
    337                             const std::string& /*in_hotspot_bssid*/,
    338                             const std::string& /*in_data*/,
    339                             std::string*,
    340                             brillo::ErrorPtr* /*error*/,
    341                             int /*timeout_ms*/) override {
    342     LOG(WARNING) << "VerifyAndEncryptData(): gmock can't handle methods with 11 arguments. You can override this method in a subclass if you need to.";
    343     return false;
    344   }
    345   void VerifyAndEncryptDataAsync(const std::string& /*in_certificate*/,
    346                                  const std::string& /*in_public_key*/,
    347                                  const std::string& /*in_nonce*/,
    348                                  const std::string& /*in_signed_data*/,
    349                                  const std::string& /*in_destination_udn*/,
    350                                  const std::string& /*in_hotspot_ssid*/,
    351                                  const std::string& /*in_hotspot_bssid*/,
    352                                  const std::string& /*in_data*/,
    353                                  const base::Callback<void(const std::string&)>& /*success_callback*/,
    354                                  const base::Callback<void(brillo::Error*)>& /*error_callback*/,
    355                                  int /*timeout_ms*/) override {
    356     LOG(WARNING) << "VerifyAndEncryptDataAsync(): gmock can't handle methods with 11 arguments. You can override this method in a subclass if you need to.";
    357   }
    358   MOCK_METHOD2(ConnectToBestServices,
    359                bool(brillo::ErrorPtr* /*error*/,
    360                     int /*timeout_ms*/));
    361   MOCK_METHOD3(ConnectToBestServicesAsync,
    362                void(const base::Callback<void()>& /*success_callback*/,
    363                     const base::Callback<void(brillo::Error*)>& /*error_callback*/,
    364                     int /*timeout_ms*/));
    365   MOCK_METHOD2(CreateConnectivityReport,
    366                bool(brillo::ErrorPtr* /*error*/,
    367                     int /*timeout_ms*/));
    368   MOCK_METHOD3(CreateConnectivityReportAsync,
    369                void(const base::Callback<void()>& /*success_callback*/,
    370                     const base::Callback<void(brillo::Error*)>& /*error_callback*/,
    371                     int /*timeout_ms*/));
    372   MOCK_METHOD4(ClaimInterface,
    373                bool(const std::string& /*in_claimer_name*/,
    374                     const std::string& /*in_interface_name*/,
    375                     brillo::ErrorPtr* /*error*/,
    376                     int /*timeout_ms*/));
    377   MOCK_METHOD5(ClaimInterfaceAsync,
    378                void(const std::string& /*in_claimer_name*/,
    379                     const std::string& /*in_interface_name*/,
    380                     const base::Callback<void()>& /*success_callback*/,
    381                     const base::Callback<void(brillo::Error*)>& /*error_callback*/,
    382                     int /*timeout_ms*/));
    383   MOCK_METHOD4(ReleaseInterface,
    384                bool(const std::string& /*in_claimer_name*/,
    385                     const std::string& /*in_interface_name*/,
    386                     brillo::ErrorPtr* /*error*/,
    387                     int /*timeout_ms*/));
    388   MOCK_METHOD5(ReleaseInterfaceAsync,
    389                void(const std::string& /*in_claimer_name*/,
    390                     const std::string& /*in_interface_name*/,
    391                     const base::Callback<void()>& /*success_callback*/,
    392                     const base::Callback<void(brillo::Error*)>& /*error_callback*/,
    393                     int /*timeout_ms*/));
    394   MOCK_METHOD3(SetSchedScan,
    395                bool(bool,
    396                     brillo::ErrorPtr* /*error*/,
    397                     int /*timeout_ms*/));
    398   MOCK_METHOD4(SetSchedScanAsync,
    399                void(bool,
    400                     const base::Callback<void()>& /*success_callback*/,
    401                     const base::Callback<void(brillo::Error*)>& /*error_callback*/,
    402                     int /*timeout_ms*/));
    403   MOCK_METHOD3(SetupApModeInterface,
    404                bool(std::string* /*out_interface_name*/,
    405                     brillo::ErrorPtr* /*error*/,
    406                     int /*timeout_ms*/));
    407   MOCK_METHOD3(SetupApModeInterfaceAsync,
    408                void(const base::Callback<void(const std::string& /*interface_name*/)>& /*success_callback*/,
    409                     const base::Callback<void(brillo::Error*)>& /*error_callback*/,
    410                     int /*timeout_ms*/));
    411   MOCK_METHOD3(SetupStationModeInterface,
    412                bool(std::string* /*out_interface_name*/,
    413                     brillo::ErrorPtr* /*error*/,
    414                     int /*timeout_ms*/));
    415   MOCK_METHOD3(SetupStationModeInterfaceAsync,
    416                void(const base::Callback<void(const std::string& /*interface_name*/)>& /*success_callback*/,
    417                     const base::Callback<void(brillo::Error*)>& /*error_callback*/,
    418                     int /*timeout_ms*/));
    419   MOCK_METHOD2(RegisterPropertyChangedSignalHandler,
    420                void(const base::Callback<void(const std::string&,
    421                                               const brillo::Any&)>& /*signal_callback*/,
    422                     dbus::ObjectProxy::OnConnectedCallback /*on_connected_callback*/));
    423   MOCK_METHOD2(RegisterStateChangedSignalHandler,
    424                void(const base::Callback<void(const std::string&)>& /*signal_callback*/,
    425                     dbus::ObjectProxy::OnConnectedCallback /*on_connected_callback*/));
    426   MOCK_CONST_METHOD0(GetObjectPath, const dbus::ObjectPath&());
    427 
    428  private:
    429   DISALLOW_COPY_AND_ASSIGN(ManagerProxyMock);
    430 };
    431 }  // namespace flimflam
    432 }  // namespace chromium
    433 }  // namespace org
    434 
    435 namespace org {
    436 namespace chromium {
    437 namespace flimflam {
    438 
    439 // Mock object for ServiceProxyInterface.
    440 class ServiceProxyMock : public ServiceProxyInterface {
    441  public:
    442   ServiceProxyMock() = default;
    443 
    444   MOCK_METHOD3(GetProperties,
    445                bool(brillo::VariantDictionary*,
    446                     brillo::ErrorPtr* /*error*/,
    447                     int /*timeout_ms*/));
    448   MOCK_METHOD3(GetPropertiesAsync,
    449                void(const base::Callback<void(const brillo::VariantDictionary&)>& /*success_callback*/,
    450                     const base::Callback<void(brillo::Error*)>& /*error_callback*/,
    451                     int /*timeout_ms*/));
    452   MOCK_METHOD4(SetProperty,
    453                bool(const std::string&,
    454                     const brillo::Any&,
    455                     brillo::ErrorPtr* /*error*/,
    456                     int /*timeout_ms*/));
    457   MOCK_METHOD5(SetPropertyAsync,
    458                void(const std::string&,
    459                     const brillo::Any&,
    460                     const base::Callback<void()>& /*success_callback*/,
    461                     const base::Callback<void(brillo::Error*)>& /*error_callback*/,
    462                     int /*timeout_ms*/));
    463   MOCK_METHOD3(SetProperties,
    464                bool(const brillo::VariantDictionary&,
    465                     brillo::ErrorPtr* /*error*/,
    466                     int /*timeout_ms*/));
    467   MOCK_METHOD4(SetPropertiesAsync,
    468                void(const brillo::VariantDictionary&,
    469                     const base::Callback<void()>& /*success_callback*/,
    470                     const base::Callback<void(brillo::Error*)>& /*error_callback*/,
    471                     int /*timeout_ms*/));
    472   MOCK_METHOD3(ClearProperty,
    473                bool(const std::string&,
    474                     brillo::ErrorPtr* /*error*/,
    475                     int /*timeout_ms*/));
    476   MOCK_METHOD4(ClearPropertyAsync,
    477                void(const std::string&,
    478                     const base::Callback<void()>& /*success_callback*/,
    479                     const base::Callback<void(brillo::Error*)>& /*error_callback*/,
    480                     int /*timeout_ms*/));
    481   MOCK_METHOD4(ClearProperties,
    482                bool(const std::vector<std::string>&,
    483                     std::vector<bool>*,
    484                     brillo::ErrorPtr* /*error*/,
    485                     int /*timeout_ms*/));
    486   MOCK_METHOD4(ClearPropertiesAsync,
    487                void(const std::vector<std::string>&,
    488                     const base::Callback<void(const std::vector<bool>&)>& /*success_callback*/,
    489                     const base::Callback<void(brillo::Error*)>& /*error_callback*/,
    490                     int /*timeout_ms*/));
    491   MOCK_METHOD2(Connect,
    492                bool(brillo::ErrorPtr* /*error*/,
    493                     int /*timeout_ms*/));
    494   MOCK_METHOD3(ConnectAsync,
    495                void(const base::Callback<void()>& /*success_callback*/,
    496                     const base::Callback<void(brillo::Error*)>& /*error_callback*/,
    497                     int /*timeout_ms*/));
    498   MOCK_METHOD2(Disconnect,
    499                bool(brillo::ErrorPtr* /*error*/,
    500                     int /*timeout_ms*/));
    501   MOCK_METHOD3(DisconnectAsync,
    502                void(const base::Callback<void()>& /*success_callback*/,
    503                     const base::Callback<void(brillo::Error*)>& /*error_callback*/,
    504                     int /*timeout_ms*/));
    505   MOCK_METHOD2(Remove,
    506                bool(brillo::ErrorPtr* /*error*/,
    507                     int /*timeout_ms*/));
    508   MOCK_METHOD3(RemoveAsync,
    509                void(const base::Callback<void()>& /*success_callback*/,
    510                     const base::Callback<void(brillo::Error*)>& /*error_callback*/,
    511                     int /*timeout_ms*/));
    512   MOCK_METHOD3(ActivateCellularModem,
    513                bool(const std::string&,
    514                     brillo::ErrorPtr* /*error*/,
    515                     int /*timeout_ms*/));
    516   MOCK_METHOD4(ActivateCellularModemAsync,
    517                void(const std::string&,
    518                     const base::Callback<void()>& /*success_callback*/,
    519                     const base::Callback<void(brillo::Error*)>& /*error_callback*/,
    520                     int /*timeout_ms*/));
    521   MOCK_METHOD2(CompleteCellularActivation,
    522                bool(brillo::ErrorPtr* /*error*/,
    523                     int /*timeout_ms*/));
    524   MOCK_METHOD3(CompleteCellularActivationAsync,
    525                void(const base::Callback<void()>& /*success_callback*/,
    526                     const base::Callback<void(brillo::Error*)>& /*error_callback*/,
    527                     int /*timeout_ms*/));
    528   MOCK_METHOD3(GetLoadableProfileEntries,
    529                bool(std::map<dbus::ObjectPath, std::string>*,
    530                     brillo::ErrorPtr* /*error*/,
    531                     int /*timeout_ms*/));
    532   MOCK_METHOD3(GetLoadableProfileEntriesAsync,
    533                void(const base::Callback<void(const std::map<dbus::ObjectPath, std::string>&)>& /*success_callback*/,
    534                     const base::Callback<void(brillo::Error*)>& /*error_callback*/,
    535                     int /*timeout_ms*/));
    536   MOCK_METHOD2(RegisterPropertyChangedSignalHandler,
    537                void(const base::Callback<void(const std::string&,
    538                                               const brillo::Any&)>& /*signal_callback*/,
    539                     dbus::ObjectProxy::OnConnectedCallback /*on_connected_callback*/));
    540   MOCK_CONST_METHOD0(GetObjectPath, const dbus::ObjectPath&());
    541 
    542  private:
    543   DISALLOW_COPY_AND_ASSIGN(ServiceProxyMock);
    544 };
    545 }  // namespace flimflam
    546 }  // namespace chromium
    547 }  // namespace org
    548 
    549 #endif  // ____CHROMEOS_DBUS_BINDING___UPDATE_ENGINE_INCLUDE_SHILL_DBUS_PROXY_MOCKS_H
    550