Split UserCloudPolicyManager implementation.

chrome/browser/profiles/profile_impl.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/profiles/profile_impl.h"
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/command_line.h"
 #include "base/compiler_specific.h"
@@ skipping 75 matching lines @@
 #include "content/public/browser/user_metrics.h"
 #include "content/public/common/content_constants.h"
 #include "grit/chromium_strings.h"
 #include "grit/generated_resources.h"
 #include "ui/base/l10n/l10n_util.h"
 
 #if defined(ENABLE_CONFIGURATION_POLICY)
 #include "chrome/browser/policy/browser_policy_connector.h"
 #include "chrome/browser/policy/managed_mode_policy_provider.h"
 #include "chrome/browser/policy/user_cloud_policy_manager.h"
+#include "chrome/browser/policy/user_cloud_policy_store.h"

[Joao da Silva, 2012/11/21 17:06:34]

These 2 are excluded from gyp when OS_CHROMEOS

[Mattias Nissler (ping if slow), 2012/11/22 20:51:59]

Thanks, this comment uncovered a deeper issue: Removing them from the #include
list would mean #ifdef-ing out GetUserCloudPolicyManager(). This actually
propagates pretty far (see TestingProfile) and gets rather awkward.

I've bitten the bullet and rolled UserCloudPolicyManager into something that
looks like a ProfileKeyedService, but with different lifetime management. As a
bonus, that allows us to remove most of the UserCloudPolicyManager references
from the Profile implementations, which is nice. WDYT?

 #else
 #include "chrome/browser/policy/policy_service_stub.h"
 #endif  // defined(ENABLE_CONFIGURATION_POLICY)
 
 #if defined(OS_WIN)
 #include "chrome/installer/util/install_util.h"
 #endif
 
 #if defined(OS_CHROMEOS)
 #include "chrome/browser/chromeos/enterprise_extension_observer.h"
@@ skipping 227 matching lines @@
 #endif
 
   // Determine if prefetch is enabled for this profile.
   // If not profile_manager is present, it means we are in a unittest.
   const CommandLine* command_line = CommandLine::ForCurrentProcess();
   predictor_ = chrome_browser_net::Predictor::CreatePredictor(
       !command_line->HasSwitch(switches::kDisablePreconnect),
       g_browser_process->profile_manager() == NULL);
 
 #if defined(ENABLE_CONFIGURATION_POLICY)
-  // TODO(atwilson): Change these to ProfileKeyedServices once PrefService is
+  // If we are creating the profile synchronously, then we should load the
+  // policy data immediately.
+  bool force_immediate_policy_load = (create_mode == CREATE_MODE_SYNCHRONOUS);
+
+  // TODO(atwilson): Change |cloud_policy_manager_| and
+  // |managed_mode_policy_provider_| to ProfileKeyedServices once PrefService is
   // a ProfileKeyedService (policy must be initialized before PrefService
   // because PrefService depends on policy loading to get overridden pref
   // values).
-  policy::BrowserPolicyConnector* connector =
-      g_browser_process->browser_policy_connector();
-  // If we are creating the profile synchronously, then we should load the
-  // policy data immediately.
-  bool force_immediate_policy_load = (create_mode == CREATE_MODE_SYNCHRONOUS);
-  cloud_policy_manager_ =
-      connector->CreateCloudPolicyManager(this, force_immediate_policy_load);
-  if (cloud_policy_manager_)
+#if !defined(OS_CHROMEOS)
+  if (command_line->HasSwitch(switches::kLoadCloudPolicyOnSignin)) {
+    scoped_ptr<policy::UserCloudPolicyStore> store(
+        policy::UserCloudPolicyStore::Create(this));

[Andrew T Wilson (Slow), 2012/11/21 17:34:24]

Hmmm. Do we like exposing this code to Profile() as opposed to hiding it off in
a factory method as it was before? I'm OK with this, I guess, but it just feels
like maybe the details of UCPM initialization (dependency on
UserCloudPolicyStore, etc) should live in UCPM::Create(), not here?

[Mattias Nissler (ping if slow), 2012/11/22 20:51:59]

Fair. Changed.

+    if (force_immediate_policy_load)
+      store->LoadImmediately();
+    cloud_policy_manager_.reset(
+        new policy::UserCloudPolicyManager(store.Pass()));
     cloud_policy_manager_->Init();
+  }
+#endif
   managed_mode_policy_provider_ =
       policy::ManagedModePolicyProvider::Create(this,
                                                 sequenced_task_runner,
                                                 force_immediate_policy_load);
   managed_mode_policy_provider_->Init();
-  policy_service_ = connector->CreatePolicyService(this);
+  policy_service_ =
+      g_browser_process->browser_policy_connector()->CreatePolicyService(this);
 #else
   policy_service_.reset(new policy::PolicyServiceStub());
 #endif
 
   if (create_mode == CREATE_MODE_ASYNCHRONOUS) {
     prefs_.reset(PrefService::CreatePrefService(
         GetPrefFilePath(),
         sequenced_task_runner,
         policy_service_.get(),
         new ExtensionPrefStore(
@@ skipping 779 matching lines @@
   if (!path.empty())
     *cache_path = path;
   *max_size = is_media_context ? prefs_->GetInteger(prefs::kMediaCacheSize) :
                                  prefs_->GetInteger(prefs::kDiskCacheSize);
 }
 
 base::Callback<ChromeURLDataManagerBackend*(void)>
     ProfileImpl::GetChromeURLDataManagerBackendGetter() const {
   return io_data_.GetChromeURLDataManagerBackendGetter();
 }