Support cloud policy for extensions on the desktop platforms.

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 "components/policy/core/common/policy_bundle.h"
 #include "components/policy/core/common/policy_pref_names.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"
 
 namespace em = enterprise_management;
 
 namespace policy {
 
 namespace {
 
 // UMA histogram names.
 const char kUMADelayInitialization[] =
@@ skipping 11 matching lines @@
 const char kUMAInitialFetchOAuth2Error[] =
     "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 base::FilePath& component_policy_cache_path,
+    bool wait_for_policy_fetch,
+    base::TimeDelta initial_policy_fetch_timeout,
     const scoped_refptr<base::SequencedTaskRunner>& task_runner,
-    const base::FilePath& resource_cache_dir,
-    bool wait_for_policy_fetch,
-    base::TimeDelta initial_policy_fetch_timeout)
+    const scoped_refptr<base::SequencedTaskRunner>& file_task_runner,
+    const scoped_refptr<base::SequencedTaskRunner>& io_task_runner)
     : CloudPolicyManager(
           PolicyNamespaceKey(dm_protocol::kChromeUserPolicyType, std::string()),
           store.get(),
-          task_runner),
+          task_runner,
+          file_task_runner,
+          io_task_runner),
       store_(store.Pass()),
       external_data_manager_(external_data_manager.Pass()),
-      resource_cache_dir_(resource_cache_dir),
+      component_policy_cache_path_(component_policy_cache_path),
       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)));
   }
@@ skipping 10 matching lines @@
   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);
 
-  CreateComponentCloudPolicyService(request_context);
+  CreateComponentCloudPolicyService(component_policy_cache_path_,
+                                    request_context);
 
   // Determine the next step after the CloudPolicyService initializes.
   if (service()->IsInitializationComplete()) {
     OnInitializationCompleted(service());
   } else {
     service()->AddObserver(this);
   }
 }
 
 void UserCloudPolicyManagerChromeOS::OnAccessTokenAvailable(
     const std::string& access_token) {
   access_token_ = access_token;
   if (service() && service()->IsInitializationComplete() &&
       client() && !client()->is_registered()) {
     OnOAuth2PolicyTokenFetched(
         access_token, GoogleServiceAuthError(GoogleServiceAuthError::NONE));
   }
 }
 
 bool UserCloudPolicyManagerChromeOS::IsClientRegistered() const {
   return client() && client()->is_registered();
 }
 
 void UserCloudPolicyManagerChromeOS::Shutdown() {
   if (client())
     client()->RemoveObserver(this);
   if (service())
     service()->RemoveObserver(this);
   token_fetcher_.reset();
-  component_policy_service_.reset();
   external_data_manager_->Disconnect();
   CloudPolicyManager::Shutdown();
 }
 
 bool UserCloudPolicyManagerChromeOS::IsInitializationComplete(
     PolicyDomain domain) const {
   if (!CloudPolicyManager::IsInitializationComplete(domain))
     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;
 }
 
-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);
   cloud_policy_service->RemoveObserver(this);
 
   time_init_completed_ = base::Time::Now();
   UMA_HISTOGRAM_TIMES(kUMADelayInitialization,
                       time_init_completed_ - time_init_started_);
 
   // If the CloudPolicyClient isn't registered at this stage then it needs an
@@ skipping 63 matching lines @@
     CloudPolicyClient* cloud_policy_client) {
   DCHECK_EQ(client(), cloud_policy_client);
   if (wait_for_policy_fetch_) {
     UMA_HISTOGRAM_SPARSE_SLOWLY(kUMAInitialFetchClientError,
                                 cloud_policy_client->status());
   }
   CancelWaitForPolicyFetch();
 }
 
 void UserCloudPolicyManagerChromeOS::OnComponentCloudPolicyUpdated() {
-  CheckAndPublishPolicy();
+  CloudPolicyManager::OnComponentCloudPolicyUpdated();
   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(),
-      core(),
-      resource_cache.Pass(),
-      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 62 matching lines @@
 void UserCloudPolicyManagerChromeOS::StartRefreshSchedulerIfReady() {
   if (core()->refresh_scheduler())
     return;  // Already started.
 
   if (wait_for_policy_fetch_)
     return;  // Still waiting for the initial, blocking fetch.
 
   if (!service() || !local_state_)
     return;  // Not connected.
 
-  if (component_policy_service_ &&
-      !component_policy_service_->is_initialized()) {
+  if (component_policy_service() &&
+      !component_policy_service()->is_initialized()) {
     // If the client doesn't have the list of components to fetch yet then don't
     // start the scheduler. The |component_policy_service_| will call back into
     // OnComponentCloudPolicyUpdated() once it's ready.
     return;
   }
 
   core()->StartRefreshScheduler();
   core()->TrackRefreshDelayPref(local_state_,
                                 policy_prefs::kUserPolicyRefreshRate);
 }
 
 }  // namespace policy