Refactored the ComponentCloudPolicyService.

chrome/browser/chromeos/policy/user_cloud_policy_manager_chromeos.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/user_cloud_policy_manager_chromeos.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
+#include "base/command_line.h"
 #include "base/logging.h"
 #include "base/message_loop/message_loop_proxy.h"
 #include "base/metrics/histogram.h"
 #include "base/metrics/sparse_histogram.h"
 #include "base/sequenced_task_runner.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/chromeos/policy/policy_oauth2_token_fetcher.h"
 #include "chrome/browser/chromeos/policy/user_cloud_policy_manager_factory_chromeos.h"
 #include "chrome/browser/chromeos/profiles/profile_helper.h"
 #include "chrome/browser/policy/cloud/cloud_external_data_manager.h"
 #include "chrome/browser/policy/cloud/cloud_policy_refresh_scheduler.h"
 #include "chrome/browser/policy/cloud/resource_cache.h"
 #include "chrome/browser/policy/policy_bundle.h"
+#include "chrome/common/chrome_switches.h"
 #include "components/policy/core/common/policy_pref_names.h"
 #include "content/public/browser/browser_thread.h"
 #include "net/url_request/url_request_context_getter.h"
 
 namespace em = enterprise_management;
 
 namespace policy {
 
 namespace {
 
@@ skipping 14 matching lines @@
     "Enterprise.UserPolicyChromeOS.InitialFetch.OAuth2Error";
 const char kUMAInitialFetchOAuth2NetworkError[] =
     "Enterprise.UserPolicyChromeOS.InitialFetch.OAuth2NetworkError";
 
 }  // namespace
 
 UserCloudPolicyManagerChromeOS::UserCloudPolicyManagerChromeOS(
     scoped_ptr<CloudPolicyStore> store,
     scoped_ptr<CloudExternalDataManager> external_data_manager,
     const scoped_refptr<base::SequencedTaskRunner>& task_runner,
-    scoped_ptr<ResourceCache> resource_cache,
+    const base::FilePath& resource_cache_dir,
     bool wait_for_policy_fetch,
     base::TimeDelta initial_policy_fetch_timeout)
     : CloudPolicyManager(
           PolicyNamespaceKey(dm_protocol::kChromeUserPolicyType, std::string()),
           store.get(),
           task_runner),
       store_(store.Pass()),
       external_data_manager_(external_data_manager.Pass()),
+      resource_cache_dir_(resource_cache_dir),
       wait_for_policy_fetch_(wait_for_policy_fetch),
       policy_fetch_timeout_(false, false) {
   time_init_started_ = base::Time::Now();
   if (wait_for_policy_fetch_) {
     policy_fetch_timeout_.Start(
         FROM_HERE,
         initial_policy_fetch_timeout,
         base::Bind(&UserCloudPolicyManagerChromeOS::CancelWaitForPolicyFetch,
                    base::Unretained(this)));
   }
-  if (resource_cache) {
-    // TODO(joaodasilva): Move the backend from the FILE thread to the blocking
-    // pool.
-    component_policy_service_.reset(new ComponentCloudPolicyService(
-        this,
-        store_.get(),
-        resource_cache.Pass(),
-        content::BrowserThread::GetMessageLoopProxyForThread(
-            content::BrowserThread::FILE),
-        content::BrowserThread::GetMessageLoopProxyForThread(
-            content::BrowserThread::IO)));
-  }
 }
 
 UserCloudPolicyManagerChromeOS::~UserCloudPolicyManagerChromeOS() {}
 
 void UserCloudPolicyManagerChromeOS::Connect(
     PrefService* local_state,
     DeviceManagementService* device_management_service,
     scoped_refptr<net::URLRequestContextGetter> request_context,
     UserAffiliation user_affiliation) {
   DCHECK(device_management_service);
   DCHECK(local_state);
   local_state_ = local_state;
   scoped_ptr<CloudPolicyClient> cloud_policy_client(
       new CloudPolicyClient(std::string(), std::string(), user_affiliation,
                             NULL, device_management_service));
   core()->Connect(cloud_policy_client.Pass());
   client()->AddObserver(this);
 
   external_data_manager_->Connect(request_context);
 
-  if (component_policy_service_)
-    component_policy_service_->Connect(client(), request_context);
+  CreateComponentCloudPolicyService(request_context);
 
   // Determine the next step after the CloudPolicyService initializes.
   if (service()->IsInitializationComplete()) {
     OnInitializationCompleted(service());
   } else {
     service()->AddObserver(this);
   }
 }
 
 void UserCloudPolicyManagerChromeOS::OnAccessTokenAvailable(
@@ skipping 27 matching lines @@
     return false;
   if (domain == POLICY_DOMAIN_CHROME)
     return !wait_for_policy_fetch_;
   if (ComponentCloudPolicyService::SupportsDomain(domain) &&
       component_policy_service_) {
     return component_policy_service_->is_initialized();
   }
   return true;
 }
 
-void UserCloudPolicyManagerChromeOS::OnSchemaRegistryUpdated(
-    bool has_new_schemas) {
-  // Send the new map even if |has_new_schemas| is false, so that policies for
-  // components that have been removed can be dropped from the cache.
-  if (component_policy_service_)
-    component_policy_service_->OnSchemasUpdated(schema_map());
-}
-
 scoped_ptr<PolicyBundle> UserCloudPolicyManagerChromeOS::CreatePolicyBundle() {
   scoped_ptr<PolicyBundle> bundle = CloudPolicyManager::CreatePolicyBundle();
   if (component_policy_service_)
     bundle->MergeFrom(component_policy_service_->policy());
   return bundle.Pass();
 }
 
 void UserCloudPolicyManagerChromeOS::OnInitializationCompleted(
     CloudPolicyService* cloud_policy_service) {
   DCHECK_EQ(service(), cloud_policy_service);
@@ skipping 78 matching lines @@
 
 void UserCloudPolicyManagerChromeOS::OnComponentCloudPolicyRefreshNeeded() {
   core()->RefreshSoon();
 }
 
 void UserCloudPolicyManagerChromeOS::OnComponentCloudPolicyUpdated() {
   CheckAndPublishPolicy();
   StartRefreshSchedulerIfReady();
 }
 
+void UserCloudPolicyManagerChromeOS::CreateComponentCloudPolicyService(
+    const scoped_refptr<net::URLRequestContextGetter>& request_context) {
+  // Init() must have been called.
+  DCHECK(schema_registry());
+  // Called at most once.
+  DCHECK(!component_policy_service_);
+
+  if (!CommandLine::ForCurrentProcess()->HasSwitch(
+           switches::kEnableComponentCloudPolicy)) {
+    return;
+  }
+
+  // TODO(joaodasilva): Move the |backend_task_runner| to the blocking pool.
+  // Currently it's not possible because the ComponentCloudPolicyStore is
+  // NonThreadSafe and doesn't support getting calls from different threads.
+  scoped_refptr<base::SequencedTaskRunner> backend_task_runner =
+      content::BrowserThread::GetMessageLoopProxyForThread(
+          content::BrowserThread::FILE);
+  scoped_ptr<ResourceCache> resource_cache(
+      new ResourceCache(resource_cache_dir_, backend_task_runner));
+  component_policy_service_.reset(new ComponentCloudPolicyService(
+      this,
+      schema_registry(),
+      store_.get(),
+      resource_cache.Pass(),
+      client(),
+      request_context,
+      backend_task_runner,
+      content::BrowserThread::GetMessageLoopProxyForThread(
+          content::BrowserThread::IO)));
+}
+
 void UserCloudPolicyManagerChromeOS::FetchPolicyOAuthTokenUsingSigninProfile() {
   scoped_refptr<net::URLRequestContextGetter> signin_context;
   Profile* signin_profile = chromeos::ProfileHelper::GetSigninProfile();
   if (signin_profile)
     signin_context = signin_profile->GetRequestContext();
   if (!signin_context.get()) {
     LOG(ERROR) << "No signin Profile for policy oauth token fetch!";
     OnOAuth2PolicyTokenFetched(
         std::string(), GoogleServiceAuthError(GoogleServiceAuthError::NONE));
     return;
@@ skipping 76 matching lines @@
     // OnComponentCloudPolicyUpdated() once it's ready.
     return;
   }
 
   core()->StartRefreshScheduler();
   core()->TrackRefreshDelayPref(local_state_,
                                 policy_prefs::kUserPolicyRefreshRate);
 }
 
 }  // namespace policy