Move ownership of the ComponentCloudPolicyService to the broker.

chrome/browser/chromeos/policy/device_local_account_policy_service.cc

 // Copyright (c) 2012 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/policy/device_local_account_policy_service.h"
 
 #include <vector>
 
 #include "base/bind.h"
+#include "base/callback.h"

[bartfab (slow), 2014/06/20 09:44:23]

Nit: Move this to the header file.

[Joao da Silva, 2014/06/20 15:36:07]

Done.

+#include "base/command_line.h"
 #include "base/file_util.h"
 #include "base/files/file_enumerator.h"
 #include "base/logging.h"
 #include "base/message_loop/message_loop.h"
 #include "base/message_loop/message_loop_proxy.h"
 #include "base/path_service.h"
 #include "base/sequenced_task_runner.h"
 #include "base/stl_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/chromeos/policy/device_local_account.h"
 #include "chrome/browser/chromeos/policy/device_local_account_external_data_service.h"
 #include "chrome/browser/chromeos/policy/device_local_account_policy_store.h"
 #include "chrome/browser/chromeos/settings/device_settings_service.h"
+#include "chrome/browser/policy/schema_registry_service.h"
 #include "chrome/common/chrome_content_client.h"
 #include "chromeos/chromeos_paths.h"
 #include "chromeos/dbus/session_manager_client.h"
 #include "chromeos/settings/cros_settings_names.h"
 #include "chromeos/settings/cros_settings_provider.h"
+#include "components/policy/core/browser/browser_policy_connector.h"
 #include "components/policy/core/common/cloud/cloud_policy_client.h"
 #include "components/policy/core/common/cloud/cloud_policy_constants.h"
 #include "components/policy/core/common/cloud/cloud_policy_refresh_scheduler.h"
 #include "components/policy/core/common/cloud/device_management_service.h"
+#include "components/policy/core/common/cloud/resource_cache.h"
 #include "components/policy/core/common/cloud/system_policy_request_context.h"
+#include "components/policy/core/common/policy_switches.h"
 #include "content/public/browser/browser_thread.h"
 #include "net/url_request/url_request_context_getter.h"
 #include "policy/policy_constants.h"
 #include "policy/proto/device_management_backend.pb.h"
 #include "url/gurl.h"
 
 namespace em = enterprise_management;
 
 namespace policy {
 
@@ skipping 65 matching lines @@
     base::DeleteFile(path, true);
 }
 
 }  // namespace
 
 DeviceLocalAccountPolicyBroker::DeviceLocalAccountPolicyBroker(
     const DeviceLocalAccount& account,
     const base::FilePath& component_policy_cache_path,
     scoped_ptr<DeviceLocalAccountPolicyStore> store,
     scoped_refptr<DeviceLocalAccountExternalDataManager> external_data_manager,
+    const base::Closure& policy_update_callback,
     const scoped_refptr<base::SequencedTaskRunner>& task_runner)
     : account_id_(account.account_id),
       user_id_(account.user_id),
       component_policy_cache_path_(component_policy_cache_path),
       store_(store.Pass()),
       external_data_manager_(external_data_manager),
       core_(PolicyNamespaceKey(dm_protocol::kChromePublicAccountPolicyType,
                                store_->account_id()),
             store_.get(),
-            task_runner) {
+            task_runner),
+      policy_update_callback_(policy_update_callback) {
   base::FilePath cache_root_dir;
   CHECK(PathService::Get(chromeos::DIR_DEVICE_LOCAL_ACCOUNT_EXTENSIONS,
                          &cache_root_dir));
   extension_loader_ = new chromeos::DeviceLocalAccountExternalPolicyLoader(
       store_.get(), cache_root_dir.Append(EncodeAccountId(account.account_id)));
+  store_->AddObserver(this);
+
+  BrowserPolicyConnector* connector =
+      g_browser_process->browser_policy_connector();
+  schema_registry_.reset(new SchemaRegistryService(
+      connector->GetChromeSchema(), connector->GetSchemaRegistry()));
 }
 
 DeviceLocalAccountPolicyBroker::~DeviceLocalAccountPolicyBroker() {
+  store_->RemoveObserver(this);
   external_data_manager_->SetPolicyStore(NULL);
   external_data_manager_->Disconnect();
+  component_policy_service_.reset();
+  if (schema_registry_)
+    schema_registry_->Shutdown();
 }
 
 void DeviceLocalAccountPolicyBroker::Initialize() {
   store_->Load();
 }
 
+void DeviceLocalAccountPolicyBroker::OnSchemaRegistryShutdown() {
+  // Make sure the |component_policy_service_| isn't observing the
+  // SchemaRegistryService anymore.
+  component_policy_service_.reset();
+}
+
+scoped_ptr<SchemaRegistryService>
+DeviceLocalAccountPolicyBroker::release_schema_registry() {
+  return schema_registry_.Pass();
+}
+
 void DeviceLocalAccountPolicyBroker::ConnectIfPossible(
     chromeos::DeviceSettingsService* device_settings_service,
     DeviceManagementService* device_management_service,
     scoped_refptr<net::URLRequestContextGetter> request_context) {
   if (core_.client())
     return;
 
   scoped_ptr<CloudPolicyClient> client(CreateClient(device_settings_service,
                                                     device_management_service,
                                                     request_context));
   if (!client)
     return;
 
   core_.Connect(client.Pass());
   external_data_manager_->Connect(request_context);
   core_.StartRefreshScheduler();
   UpdateRefreshDelay();
+  CreateComponentCloudPolicyService(request_context);
 }
 
 void DeviceLocalAccountPolicyBroker::UpdateRefreshDelay() {
   if (core_.refresh_scheduler()) {
     const base::Value* policy_value =
         store_->policy_map().GetValue(key::kPolicyRefreshRate);
     int delay = 0;
     if (policy_value && policy_value->GetAsInteger(&delay))
       core_.refresh_scheduler()->SetRefreshDelay(delay);
   }
 }
 
 std::string DeviceLocalAccountPolicyBroker::GetDisplayName() const {
   std::string display_name;
   const base::Value* display_name_value =
       store_->policy_map().GetValue(policy::key::kUserDisplayName);
   if (display_name_value)
     display_name_value->GetAsString(&display_name);
   return display_name;
 }
 
-base::FilePath DeviceLocalAccountPolicyBroker::GetComponentPolicyCachePath()
-    const {
-  return component_policy_cache_path_;
+void DeviceLocalAccountPolicyBroker::OnStoreLoaded(CloudPolicyStore* store) {
+  UpdateRefreshDelay();
+  policy_update_callback_.Run();
+}
+
+void DeviceLocalAccountPolicyBroker::OnStoreError(CloudPolicyStore* store) {
+  policy_update_callback_.Run();
+}
+
+void DeviceLocalAccountPolicyBroker::OnComponentCloudPolicyUpdated() {
+  policy_update_callback_.Run();
+}
+
+void DeviceLocalAccountPolicyBroker::CreateComponentCloudPolicyService(
+    const scoped_refptr<net::URLRequestContextGetter>& request_context) {
+  if (CommandLine::ForCurrentProcess()->HasSwitch(
+          switches::kDisableComponentCloudPolicy)) {
+    // Disabled via the command line.
+    return;
+  }
+
+  scoped_ptr<ResourceCache> resource_cache(
+      new ResourceCache(component_policy_cache_path_,
+                        content::BrowserThread::GetMessageLoopProxyForThread(
+                            content::BrowserThread::FILE)));
+
+  component_policy_service_.reset(new ComponentCloudPolicyService(
+      this,
+      schema_registry_.get(),
+      core(),
+      resource_cache.Pass(),
+      request_context,
+      content::BrowserThread::GetMessageLoopProxyForThread(
+          content::BrowserThread::FILE),
+      content::BrowserThread::GetMessageLoopProxyForThread(
+          content::BrowserThread::IO)));
 }
 
 DeviceLocalAccountPolicyService::DeviceLocalAccountPolicyService(
     chromeos::SessionManagerClient* session_manager_client,
     chromeos::DeviceSettingsService* device_settings_service,
     chromeos::CrosSettings* cros_settings,
     scoped_refptr<base::SequencedTaskRunner> store_background_task_runner,
     scoped_refptr<base::SequencedTaskRunner> extension_cache_task_runner,
     scoped_refptr<base::SequencedTaskRunner>
         external_data_service_backend_task_runner,
@@ skipping 57 matching lines @@
 
   return entry->second;
 }
 
 bool DeviceLocalAccountPolicyService::IsPolicyAvailableForUser(
     const std::string& user_id) {
   DeviceLocalAccountPolicyBroker* broker = GetBrokerForUser(user_id);
   return broker && broker->core()->store()->is_managed();
 }
 
-scoped_refptr<net::URLRequestContextGetter>
-DeviceLocalAccountPolicyService::request_context() const {
-  return request_context_;
-}
-
 void DeviceLocalAccountPolicyService::AddObserver(Observer* observer) {
   observers_.AddObserver(observer);
 }
 
 void DeviceLocalAccountPolicyService::RemoveObserver(Observer* observer) {
   observers_.RemoveObserver(observer);
 }
 
-void DeviceLocalAccountPolicyService::OnStoreLoaded(CloudPolicyStore* store) {
-  DeviceLocalAccountPolicyBroker* broker = GetBrokerForStore(store);
-  DCHECK(broker);
-  if (!broker)
-    return;
-  broker->UpdateRefreshDelay();
-  FOR_EACH_OBSERVER(Observer, observers_, OnPolicyUpdated(broker->user_id()));
-}
-
-void DeviceLocalAccountPolicyService::OnStoreError(CloudPolicyStore* store) {
-  DeviceLocalAccountPolicyBroker* broker = GetBrokerForStore(store);
-  DCHECK(broker);
-  if (!broker)
-    return;
-  FOR_EACH_OBSERVER(Observer, observers_, OnPolicyUpdated(broker->user_id()));
-}
-
 bool DeviceLocalAccountPolicyService::IsExtensionCacheDirectoryBusy(
     const std::string& account_id) {
   return busy_extension_cache_directories_.find(account_id) !=
             busy_extension_cache_directories_.end();
 }
 
 void DeviceLocalAccountPolicyService::StartExtensionCachesIfPossible() {
   for (PolicyBrokerMap::iterator it = policy_brokers_.begin();
        it != policy_brokers_.end(); ++it) {
     if (!it->second->extension_loader()->IsCacheRunning() &&
@@ skipping 107 matching lines @@
       // Reuse the existing broker if present.
       broker.reset(broker_it->second);
       old_policy_brokers.erase(broker_it);
       broker_initialized = true;
     } else {
       scoped_ptr<DeviceLocalAccountPolicyStore> store(
           new DeviceLocalAccountPolicyStore(it->account_id,
                                             session_manager_client_,
                                             device_settings_service_,
                                             store_background_task_runner_));
-      store->AddObserver(this);
       scoped_refptr<DeviceLocalAccountExternalDataManager>
           external_data_manager =
               external_data_service_->GetExternalDataManager(it->account_id,
                                                              store.get());
       broker.reset(new DeviceLocalAccountPolicyBroker(
           *it,
           component_policy_cache_root_.Append(EncodeAccountId(it->account_id)),
           store.Pass(),
           external_data_manager,
+          base::Bind(&DeviceLocalAccountPolicyService::NotifyPolicyUpdated,
+                     base::Unretained(this),

[bartfab (slow), 2014/06/20 09:44:23]

Nit: #include "base/bind_helpers.h"

[Joao da Silva, 2014/06/20 15:36:07]

Done.

+                     it->user_id),
           base::MessageLoopProxy::current()));
     }
 
     // Fire up the cloud connection for fetching policy for the account from
     // the cloud if this is an enterprise-managed device.
     broker->ConnectIfPossible(device_settings_service_,
                               device_management_service_,
                               request_context_);
 
     policy_brokers_[it->user_id] = broker.release();
@@ skipping 51 matching lines @@
   content::BrowserThread::PostTask(content::BrowserThread::FILE, FROM_HERE,
                                    base::Bind(&DeleteOrphanedCaches,
                                               component_policy_cache_root_,
                                               subdirectories_to_keep));
 
   FOR_EACH_OBSERVER(Observer, observers_, OnDeviceLocalAccountsChanged());
 }
 
 void DeviceLocalAccountPolicyService::DeleteBrokers(PolicyBrokerMap* map) {
   for (PolicyBrokerMap::iterator it = map->begin(); it != map->end(); ++it) {
-    it->second->core()->store()->RemoveObserver(this);
     scoped_refptr<chromeos::DeviceLocalAccountExternalPolicyLoader>
         extension_loader = it->second->extension_loader();
     if (extension_loader->IsCacheRunning()) {
       DCHECK(!IsExtensionCacheDirectoryBusy(it->second->account_id()));
       busy_extension_cache_directories_.insert(it->second->account_id());
       extension_loader->StopCache(base::Bind(
           &DeviceLocalAccountPolicyService::OnObsoleteExtensionCacheShutdown,
           weak_factory_.GetWeakPtr(),
           it->second->account_id()));
     }
-    FOR_EACH_OBSERVER(Observer, observers_, OnBrokerShutdown(it->second));
+
     delete it->second;
   }
   map->clear();
 }
 
 DeviceLocalAccountPolicyBroker*
     DeviceLocalAccountPolicyService::GetBrokerForStore(
         CloudPolicyStore* store) {
   for (PolicyBrokerMap::iterator it(policy_brokers_.begin());
        it != policy_brokers_.end(); ++it) {
     if (it->second->core()->store() == store)
       return it->second;
   }
   return NULL;
 }
 
+void DeviceLocalAccountPolicyService::NotifyPolicyUpdated(
+    const std::string& user_id) {
+  FOR_EACH_OBSERVER(Observer, observers_, OnPolicyUpdated(user_id));
+}
+
 }  // namespace policy