Break out base functionality of UserCloudPolicyManager.

chrome/browser/policy/user_cloud_policy_manager.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/policy/user_cloud_policy_manager.h"
 
-#include <string>
-
-#include "base/command_line.h"
-#include "base/file_path.h"
-#include "base/message_loop.h"
-#include "base/path_service.h"
-#include "chrome/browser/policy/cloud_policy_refresh_scheduler.h"
+#include "base/bind.h"
+#include "base/bind_helpers.h"
 #include "chrome/browser/policy/cloud_policy_service.h"
 #include "chrome/browser/policy/policy_constants.h"
-#include "chrome/common/chrome_paths.h"
-#include "chrome/common/chrome_switches.h"
 #include "chrome/common/pref_names.h"
 
-#if defined(OS_CHROMEOS)
-#include "chrome/browser/policy/user_cloud_policy_store_chromeos.h"
-#include "chromeos/dbus/dbus_thread_manager.h"
-#include "chromeos/dbus/session_manager_client.h"
-#endif
-
 namespace policy {
 
-namespace {
-
-#if defined(OS_CHROMEOS)
-// Paths for the legacy policy caches in the profile directory.
-// TODO(mnissler): Remove once the number of pre-M20 clients becomes negligible.
-
-// Subdirectory in the user's profile for storing user policies.
-const FilePath::CharType kPolicyDir[] = FILE_PATH_LITERAL("Device Management");
-// File in the above directory for storing user policy dmtokens.
-const FilePath::CharType kTokenCacheFile[] = FILE_PATH_LITERAL("Token");
-// File in the above directory for storing user policy data.
-const FilePath::CharType kPolicyCacheFile[] = FILE_PATH_LITERAL("Policy");
-#endif
-
-}  // namespace
-
 UserCloudPolicyManager::UserCloudPolicyManager(
     scoped_ptr<CloudPolicyStore> store,
     bool wait_for_policy_fetch)
-    : wait_for_policy_fetch_(wait_for_policy_fetch),
-      wait_for_policy_refresh_(false),
-      store_(store.Pass()) {
-  store_->Load();
-  store_->AddObserver(this);
-}
+    : CloudPolicyManager(store.Pass()),
+      wait_for_policy_fetch_(wait_for_policy_fetch) {}
 
 UserCloudPolicyManager::~UserCloudPolicyManager() {
-  Shutdown();
-  store_->RemoveObserver(this);
+  if (cloud_policy_client())
+    cloud_policy_client()->RemoveObserver(this);
 }
 
 // static
 scoped_ptr<UserCloudPolicyManager> UserCloudPolicyManager::Create(
     Profile* profile,
     bool wait_for_policy_fetch) {
   scoped_ptr<CloudPolicyStore> store =
       CloudPolicyStore::CreateUserPolicyStore(profile);
   return scoped_ptr<UserCloudPolicyManager>(
       new UserCloudPolicyManager(store.Pass(), wait_for_policy_fetch));
 }
 
-void UserCloudPolicyManager::Initialize(PrefService* prefs,
-                                        DeviceManagementService* service,
-                                        UserAffiliation user_affiliation) {
-  DCHECK(service);
-  DCHECK(prefs);
-  DCHECK(!service_.get());
-  prefs_ = prefs;
+void UserCloudPolicyManager::Initialize(
+    PrefService* local_state,
+    DeviceManagementService* device_management_service,
+    UserAffiliation user_affiliation) {
+  DCHECK(device_management_service);
+  DCHECK(local_state);
+  local_state_ = local_state;
   scoped_ptr<CloudPolicyClient> client(
       new CloudPolicyClient(std::string(), std::string(), user_affiliation,
-                            POLICY_SCOPE_USER, NULL, service));
-  service_.reset(new CloudPolicyService(client.Pass(), store_.get()));
-  service_->client()->AddObserver(this);
+                            POLICY_SCOPE_USER, NULL,
+                            device_management_service));
+  InitializeService(client.Pass());
+  cloud_policy_client()->AddObserver(this);
 
   if (wait_for_policy_fetch_) {
     // If we are supposed to wait for a policy fetch, we trigger an explicit
     // policy refresh at startup that allows us to unblock initialization once
     // done. The refresh scheduler only gets started once that refresh
     // completes. Note that we might have to wait for registration to happen,
     // see OnRegistrationStateChanged() below.
-    if (service_->client()->is_registered()) {
-      service_->RefreshPolicy(
+    if (cloud_policy_client()->is_registered()) {
+      cloud_policy_service()->RefreshPolicy(
           base::Bind(&UserCloudPolicyManager::OnInitialPolicyFetchComplete,
                      base::Unretained(this)));
     }
   } else {
     CancelWaitForPolicyFetch();
   }
 }
 
 void UserCloudPolicyManager::ShutdownAndRemovePolicy() {
-  Shutdown();
-  store_->Clear();
+  if (cloud_policy_client())
+    cloud_policy_client()->RemoveObserver(this);
+  ShutdownService();
+  local_state_ = NULL;
+  cloud_policy_store()->Clear();
 }
 
 void UserCloudPolicyManager::CancelWaitForPolicyFetch() {
   wait_for_policy_fetch_ = false;
   CheckAndPublishPolicy();
 
   // Now that |wait_for_policy_fetch_| is guaranteed to be false, the scheduler
   // can be started.
-  if (service_.get() && !refresh_scheduler_.get() && prefs_) {
-    refresh_scheduler_.reset(
-        new CloudPolicyRefreshScheduler(
-            service_->client(), store_.get(), prefs_,
-            prefs::kUserPolicyRefreshRate,
-            MessageLoop::current()->message_loop_proxy()));
-  }
+  if (cloud_policy_service() && local_state_)
+    StartRefreshScheduler(local_state_, prefs::kUserPolicyRefreshRate);
 }
 
 bool UserCloudPolicyManager::IsClientRegistered() const {
-  if (!service_.get())
-    return false;
-  return service_->client()->is_registered();
+  return cloud_policy_client() && cloud_policy_client()->is_registered();
 }
 
 void UserCloudPolicyManager::RegisterClient(const std::string& access_token) {
-  DCHECK(cloud_policy_service()) << "Callers must invoke Initialize() first";
-  if (!cloud_policy_service()->client()->is_registered()) {
+  DCHECK(cloud_policy_client()) << "Callers must invoke Initialize() first";
+  if (!cloud_policy_client()->is_registered()) {
     DVLOG(1) << "Registering client with access token: " << access_token;
-    cloud_policy_service()->client()->Register(access_token);
+    cloud_policy_client()->Register(access_token);
   }
 }
 
 bool UserCloudPolicyManager::IsInitializationComplete() const {
-  return store_->is_initialized() && !wait_for_policy_fetch_;
-}
-
-void UserCloudPolicyManager::RefreshPolicies() {
-  if (service_.get()) {
-    wait_for_policy_refresh_ = true;
-    service_->RefreshPolicy(
-        base::Bind(&UserCloudPolicyManager::OnRefreshComplete,
-                   base::Unretained(this)));
-  } else {
-    OnRefreshComplete();
-  }
+  return CloudPolicyManager::IsInitializationComplete() &&
+      !wait_for_policy_fetch_;
 }
 
 void UserCloudPolicyManager::OnPolicyFetched(CloudPolicyClient* client) {
   // No action required. If we're blocked on a policy fetch, we'll learn about
   // completion of it through OnInitialPolicyFetchComplete().
 }
 
 void UserCloudPolicyManager::OnRegistrationStateChanged(
     CloudPolicyClient* client) {
+  DCHECK_EQ(cloud_policy_client(), client);
   if (wait_for_policy_fetch_) {
     // If we're blocked on the policy fetch, now is a good time to issue it.
-    if (service_->client()->is_registered()) {
-      service_->RefreshPolicy(
+    if (cloud_policy_client()->is_registered()) {
+      cloud_policy_service()->RefreshPolicy(
           base::Bind(&UserCloudPolicyManager::OnInitialPolicyFetchComplete,
                      base::Unretained(this)));
     } else {
       // If the client has switched to not registered, we bail out as this
       // indicates the cloud policy setup flow has been aborted.
       CancelWaitForPolicyFetch();
     }
   }
 }
 
 void UserCloudPolicyManager::OnClientError(CloudPolicyClient* client) {
+  DCHECK_EQ(cloud_policy_client(), client);
   CancelWaitForPolicyFetch();
 }
 
-void UserCloudPolicyManager::CheckAndPublishPolicy() {
-  if (IsInitializationComplete() && !wait_for_policy_refresh_) {
-    scoped_ptr<PolicyBundle> bundle(new PolicyBundle());
-    bundle->Get(POLICY_DOMAIN_CHROME, std::string()).CopyFrom(
-        store_->policy_map());
-    UpdatePolicy(bundle.Pass());
-  }
-}
-
-void UserCloudPolicyManager::OnStoreLoaded(CloudPolicyStore* store) {
-  CheckAndPublishPolicy();
-}
-
-void UserCloudPolicyManager::OnStoreError(CloudPolicyStore* store) {
-  // No action required, the old policy is still valid.
-}
-
 void UserCloudPolicyManager::OnInitialPolicyFetchComplete() {
   CancelWaitForPolicyFetch();
 }
 
-void UserCloudPolicyManager::OnRefreshComplete() {
-  wait_for_policy_refresh_ = false;
-  CheckAndPublishPolicy();
-}
-
-void UserCloudPolicyManager::Shutdown() {
-  refresh_scheduler_.reset();
-  if (service_.get())
-    service_->client()->RemoveObserver(this);
-  service_.reset();
-  prefs_ = NULL;
-}
-
 }  // namespace policy