arc: Revamp the ArcBridgeService interface

chrome/browser/chromeos/arc/arc_policy_bridge.cc

 // Copyright 2016 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 "chrome/browser/chromeos/arc/arc_policy_bridge.h"
 
 #include <memory>
 #include <string>
 
 #include "base/json/json_reader.h"
@@ skipping 216 matching lines @@
   JSONStringValueSerializer serializer(&policy_json);
   serializer.Serialize(filtered_policies);
   return policy_json;
 }
 
 }  // namespace
 
 ArcPolicyBridge::ArcPolicyBridge(ArcBridgeService* bridge_service)
     : ArcService(bridge_service), binding_(this) {
   VLOG(2) << "ArcPolicyBridge::ArcPolicyBridge";
-  arc_bridge_service()->AddObserver(this);
+  arc_bridge_service()->policy()->AddObserver(this);
 }
 
 ArcPolicyBridge::ArcPolicyBridge(ArcBridgeService* bridge_service,
                                  policy::PolicyService* policy_service)
     : ArcService(bridge_service),
       binding_(this),
       policy_service_(policy_service) {
   VLOG(2) << "ArcPolicyBridge::ArcPolicyBridge(bridge_service, policy_service)";
-  arc_bridge_service()->AddObserver(this);
+  arc_bridge_service()->policy()->AddObserver(this);
 }
 
 ArcPolicyBridge::~ArcPolicyBridge() {
   VLOG(2) << "ArcPolicyBridge::~ArcPolicyBridge";
-  arc_bridge_service()->RemoveObserver(this);
+  arc_bridge_service()->policy()->RemoveObserver(this);
 }
 
 void ArcPolicyBridge::OverrideIsManagedForTesting(bool is_managed) {
   is_managed_ = is_managed;
 }
 
-void ArcPolicyBridge::OnPolicyInstanceReady() {
+void ArcPolicyBridge::OnInstanceReady(mojom::PolicyInstance* policy_instance,
+                                      uint32_t version) {
   VLOG(1) << "ArcPolicyBridge::OnPolicyInstanceReady";
   if (policy_service_ == nullptr) {
     InitializePolicyService();
   }
   policy_service_->AddObserver(policy::POLICY_DOMAIN_CHROME, this);
 
-  mojom::PolicyInstance* const policy_instance =
-      arc_bridge_service()->policy_instance();
-  if (!policy_instance) {
-    LOG(ERROR) << "OnPolicyInstanceReady called, but no policy instance found";
-    return;
-  }
-
   policy_instance->Init(binding_.CreateInterfacePtrAndBind());
 }
 
-void ArcPolicyBridge::OnPolicyInstanceClosed() {
+void ArcPolicyBridge::OnInstanceClosed(mojom::PolicyInstance*) {
   VLOG(1) << "ArcPolicyBridge::OnPolicyInstanceClosed";
   policy_service_->RemoveObserver(policy::POLICY_DOMAIN_CHROME, this);
   policy_service_ = nullptr;
 }
 
 void ArcPolicyBridge::GetPolicies(const GetPoliciesCallback& callback) {
   VLOG(1) << "ArcPolicyBridge::GetPolicies";
   if (!is_managed_) {
     callback.Run(mojo::String(""));
     return;
   }
   const policy::PolicyNamespace policy_namespace(policy::POLICY_DOMAIN_CHROME,
                                                  std::string());
   const policy::PolicyMap& policy_map =
       policy_service_->GetPolicies(policy_namespace);
   const std::string json_policies = GetFilteredJSONPolicies(policy_map);
   callback.Run(mojo::String(json_policies));
 }
 
 void ArcPolicyBridge::OnPolicyUpdated(const policy::PolicyNamespace& ns,
                                       const policy::PolicyMap& previous,
                                       const policy::PolicyMap& current) {
   VLOG(1) << "ArcPolicyBridge::OnPolicyUpdated";
-  DCHECK(arc_bridge_service()->policy_instance());
-  arc_bridge_service()->policy_instance()->OnPolicyUpdated();
+  DCHECK(arc_bridge_service()->policy()->instance());
+  arc_bridge_service()->policy()->instance()->OnPolicyUpdated();
 }
 
 void ArcPolicyBridge::InitializePolicyService() {
   const user_manager::User* const primary_user =
       user_manager::UserManager::Get()->GetPrimaryUser();
   Profile* const profile =
       chromeos::ProfileHelper::Get()->GetProfileByUser(primary_user);
   auto profile_policy_connector =
       policy::ProfilePolicyConnectorFactory::GetForBrowserContext(profile);
   policy_service_ = profile_policy_connector->policy_service();
   is_managed_ = profile_policy_connector->IsManaged();
 }
 
 }  // namespace arc