arc: Revamp the ArcBridgeService interface

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 <memory>
 #include <string>
 #include <vector>
 
@@ skipping 287 matching lines @@
     std::unique_ptr<base::DictionaryValue> error_data) {
   LOG(ERROR) << "Failed to query default logical network";
 }
 
 }  // namespace
 
 namespace arc {
 
 ArcNetHostImpl::ArcNetHostImpl(ArcBridgeService* bridge_service)
     : ArcService(bridge_service), binding_(this), weak_factory_(this) {
-  arc_bridge_service()->AddObserver(this);
+  arc_bridge_service()->net()->AddObserver(this);
   GetStateHandler()->AddObserver(this, FROM_HERE);
 }
 
 ArcNetHostImpl::~ArcNetHostImpl() {
   DCHECK(thread_checker_.CalledOnValidThread());
-  arc_bridge_service()->RemoveObserver(this);
+  arc_bridge_service()->net()->RemoveObserver(this);
   if (chromeos::NetworkHandler::IsInitialized()) {
     GetStateHandler()->RemoveObserver(this, FROM_HERE);
   }
 }
 
-void ArcNetHostImpl::OnNetInstanceReady() {
+void ArcNetHostImpl::OnInstanceReady(mojom::NetInstance* net_instance,
+                                     uint32_t version) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   mojom::NetHostPtr host;
   binding_.Bind(GetProxy(&host));
-  arc_bridge_service()->net_instance()->Init(std::move(host));
+  net_instance->Init(std::move(host));
 }
 
 void ArcNetHostImpl::GetNetworksDeprecated(
     bool configured_only,
     bool visible_only,
     const GetNetworksDeprecatedCallback& callback) {
   DCHECK(thread_checker_.CalledOnValidThread());
   if (configured_only && visible_only) {
     VLOG(1) << "Illegal arguments - both configured and visible networks "
                "requested.";
@@ skipping 210 matching lines @@
         chromeos::network_handler::ErrorCallback());
     callback.Run(true);
   }
 }
 
 void ArcNetHostImpl::StartScan() {
   GetStateHandler()->RequestScan();
 }
 
 void ArcNetHostImpl::ScanCompleted(const chromeos::DeviceState* /*unused*/) {
-  if (!arc_bridge_service()->net_instance()) {
+  if (!arc_bridge_service()->net()->instance()) {
     VLOG(2) << "NetInstance not ready yet";
     return;
   }
-  if (arc_bridge_service()->net_version() < 1) {
+  if (arc_bridge_service()->net()->version() < 1) {
     VLOG(1) << "NetInstance does not support ScanCompleted.";
     return;
   }
 
-  arc_bridge_service()->net_instance()->ScanCompleted();
+  arc_bridge_service()->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) {
-  arc_bridge_service()->net_instance()->DefaultNetworkChanged(
+  arc_bridge_service()->net()->instance()->DefaultNetworkChanged(
       TranslateONCConfiguration(&dictionary),
       TranslateONCConfiguration(&dictionary));
 }
 
 void ArcNetHostImpl::DefaultNetworkChanged(
     const chromeos::NetworkState* network) {
-  if (arc_bridge_service()->net_version() < 2) {
+  if (arc_bridge_service()->net()->version() < 2) {
     VLOG(1) << "ArcBridgeService does not support DefaultNetworkChanged.";
     return;
   }
 
   if (!network) {
     VLOG(1) << "No default network";
-    arc_bridge_service()->net_instance()->DefaultNetworkChanged(nullptr,
-                                                                nullptr);
+    arc_bridge_service()->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(&arc::ArcNetHostImpl::DefaultNetworkSuccessCallback,
                  weak_factory_.GetWeakPtr()),
       base::Bind(&DefaultNetworkFailureCallback));
 }
 
 void ArcNetHostImpl::DeviceListChanged() {
-  if (arc_bridge_service()->net_version() < 3) {
+  if (arc_bridge_service()->net()->version() < 3) {
     VLOG(1) << "ArcBridgeService does not support DeviceListChanged.";
     return;
   }
 
   bool is_enabled = GetStateHandler()->IsTechnologyEnabled(
       chromeos::NetworkTypePattern::WiFi());
-  arc_bridge_service()->net_instance()->WifiEnabledStateChanged(is_enabled);
+  arc_bridge_service()->net()->instance()->WifiEnabledStateChanged(is_enabled);
 }
 
 void ArcNetHostImpl::OnShuttingDown() {
   GetStateHandler()->RemoveObserver(this, FROM_HERE);
 }
 
 }  // namespace arc