arc: Use GET_INTERFACE_FOR_METHOD macro

components/arc/net/arc_net_host_impl.cc

 // Copyright 2015 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "components/arc/net/arc_net_host_impl.h"
 
 #include <string>
 #include <utility>
 #include <vector>
 
@@ skipping 10 matching lines @@
 #include "chromeos/network/network_state.h"
 #include "chromeos/network/network_state_handler.h"
 #include "chromeos/network/network_type_pattern.h"
 #include "chromeos/network/network_util.h"
 #include "chromeos/network/onc/onc_utils.h"
 #include "components/arc/arc_bridge_service.h"
 
 namespace {
 
 constexpr int kGetNetworksListLimit = 100;
-constexpr uint32_t kScanCompletedMinInstanceVersion = 1;
-constexpr uint32_t kDefaultNetworkChangedMinInstanceVersion = 2;
-constexpr uint32_t kWifiEnabledStateChanged = 3;
 
 chromeos::NetworkStateHandler* GetStateHandler() {
   return chromeos::NetworkHandler::Get()->network_state_handler();
 }
 
 chromeos::ManagedNetworkConfigurationHandler* GetManagedConfigurationHandler() {
   return chromeos::NetworkHandler::Get()
       ->managed_network_configuration_handler();
 }
 
@@ skipping 256 matching lines @@
   if (observing_network_state_) {
     GetStateHandler()->RemoveObserver(this, FROM_HERE);
   }
 }
 
 void ArcNetHostImpl::OnInstanceReady() {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   mojom::NetHostPtr host;
   binding_.Bind(MakeRequest(&host));
-  auto* instance = arc_bridge_service()->net()->GetInstanceForMethod("Init");
+  auto* instance =
+      ARC_GET_INSTANCE_FOR_METHOD(arc_bridge_service()->net(), Init);
   DCHECK(instance);
   instance->Init(std::move(host));
 
   if (chromeos::NetworkHandler::IsInitialized()) {
     GetStateHandler()->AddObserver(this, FROM_HERE);
     observing_network_state_ = true;
   }
 }
 
 void ArcNetHostImpl::OnInstanceClosed() {
@@ skipping 259 matching lines @@
         chromeos::network_handler::ErrorCallback());
     callback.Run(true);
   }
 }
 
 void ArcNetHostImpl::StartScan() {
   GetStateHandler()->RequestScan();
 }
 
 void ArcNetHostImpl::ScanCompleted(const chromeos::DeviceState* /*unused*/) {
-  auto* net_instance = arc_bridge_service()->net()->GetInstanceForMethod(
-      "ScanCompleted", kScanCompletedMinInstanceVersion);
+  auto* net_instance =
+      ARC_GET_INSTANCE_FOR_METHOD(arc_bridge_service()->net(), ScanCompleted);
   if (!net_instance)
     return;
 
   net_instance->ScanCompleted();
 }
 
 void ArcNetHostImpl::GetDefaultNetwork(
     const GetDefaultNetworkCallback& callback) {
   const chromeos::NetworkState* default_network =
       GetStateHandler()->DefaultNetwork();
   if (!default_network) {
     VLOG(1) << "GetDefaultNetwork: no default network";
     callback.Run(nullptr, nullptr);
     return;
   }
   VLOG(1) << "GetDefaultNetwork: default network is "
           << default_network->path();
   std::string user_id_hash = chromeos::LoginState::Get()->primary_user_hash();
   GetManagedConfigurationHandler()->GetProperties(
       user_id_hash, default_network->path(),
       base::Bind(&GetDefaultNetworkSuccessCallback, callback),
       base::Bind(&GetDefaultNetworkFailureCallback, callback));
 }
 
 void ArcNetHostImpl::DefaultNetworkSuccessCallback(
     const std::string& service_path,
     const base::DictionaryValue& dictionary) {
-  auto* net_instance = arc_bridge_service()->net()->GetInstanceForMethod(
-      "DefaultNetworkChanged", kDefaultNetworkChangedMinInstanceVersion);
+  auto* net_instance = ARC_GET_INSTANCE_FOR_METHOD(arc_bridge_service()->net(),
+                                                   DefaultNetworkChanged);
   if (!net_instance)
     return;
 
   net_instance->DefaultNetworkChanged(TranslateONCConfiguration(&dictionary),
                                       TranslateONCConfiguration(&dictionary));
 }
 
 void ArcNetHostImpl::DefaultNetworkChanged(
     const chromeos::NetworkState* network) {
   if (!network) {
     VLOG(1) << "No default network";
-    auto* net_instance = arc_bridge_service()->net()->GetInstanceForMethod(
-        "DefaultNetworkChanged", kDefaultNetworkChangedMinInstanceVersion);
+    auto* net_instance = ARC_GET_INSTANCE_FOR_METHOD(
+        arc_bridge_service()->net(), DefaultNetworkChanged);
     if (net_instance)
       net_instance->DefaultNetworkChanged(nullptr, nullptr);
     return;
   }
 
   VLOG(1) << "New default network: " << network->path();
   std::string user_id_hash = chromeos::LoginState::Get()->primary_user_hash();
   GetManagedConfigurationHandler()->GetProperties(
       user_id_hash, network->path(),
       base::Bind(&ArcNetHostImpl::DefaultNetworkSuccessCallback,
                  weak_factory_.GetWeakPtr()),
       base::Bind(&DefaultNetworkFailureCallback));
 }
 
 void ArcNetHostImpl::DeviceListChanged() {
-  auto* net_instance = arc_bridge_service()->net()->GetInstanceForMethod(
-      "WifiEnabledStateChanged", kWifiEnabledStateChanged);
+  auto* net_instance = ARC_GET_INSTANCE_FOR_METHOD(arc_bridge_service()->net(),
+                                                   WifiEnabledStateChanged);
   if (!net_instance)
     return;
 
   bool is_enabled = GetStateHandler()->IsTechnologyEnabled(
       chromeos::NetworkTypePattern::WiFi());
   net_instance->WifiEnabledStateChanged(is_enabled);
 }
 
 void ArcNetHostImpl::OnShuttingDown() {
   DCHECK(observing_network_state_);
   GetStateHandler()->RemoveObserver(this, FROM_HERE);
   observing_network_state_ = false;
 }
 
 }  // namespace arc