Add support for loading user cloud policy on desktop.

chrome/test/base/testing_profile.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/test/base/testing_profile.h"
 
 #include "build/build_config.h"
 
 #include "base/base_paths.h"
 #include "base/command_line.h"
@@ skipping 16 matching lines @@
 #include "chrome/browser/geolocation/chrome_geolocation_permission_context.h"
 #include "chrome/browser/history/history.h"
 #include "chrome/browser/history/history_backend.h"
 #include "chrome/browser/history/history_service_factory.h"
 #include "chrome/browser/history/shortcuts_backend.h"
 #include "chrome/browser/history/shortcuts_backend_factory.h"
 #include "chrome/browser/history/top_sites.h"
 #include "chrome/browser/net/proxy_service_factory.h"
 #include "chrome/browser/notifications/desktop_notification_service.h"
 #include "chrome/browser/notifications/desktop_notification_service_factory.h"
+#include "chrome/browser/policy/user_cloud_policy_manager.h"
 #include "chrome/browser/prefs/browser_prefs.h"
 #include "chrome/browser/prefs/testing_pref_store.h"
 #include "chrome/browser/prerender/prerender_manager.h"
 #include "chrome/browser/profiles/profile_dependency_manager.h"
 #include "chrome/browser/protector/protector_service_factory.h"
 #include "chrome/browser/search_engines/template_url_fetcher_factory.h"
 #include "chrome/browser/speech/chrome_speech_recognition_preferences.h"
 #include "chrome/browser/webdata/web_data_service.h"
 #include "chrome/browser/webdata/web_data_service_factory.h"
 #include "chrome/common/chrome_constants.h"
@@ skipping 105 matching lines @@
 const char TestingProfile::kTestUserProfileDir[] = "Default";
 #endif
 
 TestingProfile::TestingProfile()
     : start_time_(Time::Now()),
       testing_prefs_(NULL),
       incognito_(false),
       last_session_exited_cleanly_(true),
       profile_dependency_manager_(ProfileDependencyManager::GetInstance()),
       delegate_(NULL) {
-  if (!temp_dir_.CreateUniqueTempDir()) {
-    LOG(ERROR) << "Failed to create unique temporary directory.";
-
-    // Fallback logic in case we fail to create unique temporary directory.
-    FilePath system_tmp_dir;
-    bool success = PathService::Get(base::DIR_TEMP, &system_tmp_dir);
-
-    // We're severly screwed if we can't get the system temporary
-    // directory. Die now to avoid writing to the filesystem root
-    // or other bad places.
-    CHECK(success);
-
-    FilePath fallback_dir(system_tmp_dir.AppendASCII("TestingProfilePath"));
-    file_util::Delete(fallback_dir, true);
-    file_util::CreateDirectory(fallback_dir);
-    if (!temp_dir_.Set(fallback_dir)) {
-      // That shouldn't happen, but if it does, try to recover.
-      LOG(ERROR) << "Failed to use a fallback temporary directory.";
-
-      // We're screwed if this fails, see CHECK above.
-      CHECK(temp_dir_.Set(system_tmp_dir));
-    }
-  }
-
+  CreateTempProfileDir();
   profile_path_ = temp_dir_.path();
 
   Init();
   FinishInit();
 }
 
 TestingProfile::TestingProfile(const FilePath& path)
     : start_time_(Time::Now()),
       testing_prefs_(NULL),
       incognito_(false),
@@ skipping 17 matching lines @@
   Init();
   if (delegate_) {
     MessageLoop::current()->PostTask(FROM_HERE,
                                      base::Bind(&TestingProfile::FinishInit,
                                                 base::Unretained(this)));
   } else {
     FinishInit();
   }
 }
 
+TestingProfile::TestingProfile(
+    const FilePath& path,
+    Delegate* delegate,
+    scoped_refptr<ExtensionSpecialStoragePolicy> extension_policy,
+    scoped_ptr<PrefService> prefs,
+    scoped_ptr<policy::UserCloudPolicyManager> user_cloud_policy_manager)
+    : start_time_(Time::Now()),
+      prefs_(prefs.release()),
+      testing_prefs_(NULL),
+      incognito_(false),
+      last_session_exited_cleanly_(true),
+      extension_special_storage_policy_(extension_policy),
+      user_cloud_policy_manager_(user_cloud_policy_manager.release()),
+      profile_path_(path),
+      profile_dependency_manager_(ProfileDependencyManager::GetInstance()),
+      delegate_(delegate) {
+
+  // If no profile path was supplied, create one.
+  if (profile_path_.empty()) {
+    CreateTempProfileDir();
+    profile_path_ = temp_dir_.path();
+  }
+
+  Init();
+  // If caller supplied a delegate, delay the FinishInit invocation until other
+  // tasks have run.
+  // TODO(atwilson): See if this is still required once we convert the current
+  // users of the constructor that takes a Delegate* param.
+  if (delegate_) {
+    MessageLoop::current()->PostTask(FROM_HERE,
+                                     base::Bind(&TestingProfile::FinishInit,
+                                                base::Unretained(this)));
+  } else {
+    FinishInit();
+  }
+}
+
+void TestingProfile::CreateTempProfileDir() {
+  if (!temp_dir_.CreateUniqueTempDir()) {
+    LOG(ERROR) << "Failed to create unique temporary directory.";
+
+    // Fallback logic in case we fail to create unique temporary directory.
+    FilePath system_tmp_dir;
+    bool success = PathService::Get(base::DIR_TEMP, &system_tmp_dir);
+
+    // We're severly screwed if we can't get the system temporary
+    // directory. Die now to avoid writing to the filesystem root
+    // or other bad places.
+    CHECK(success);
+
+    FilePath fallback_dir(system_tmp_dir.AppendASCII("TestingProfilePath"));
+    file_util::Delete(fallback_dir, true);
+    file_util::CreateDirectory(fallback_dir);
+    if (!temp_dir_.Set(fallback_dir)) {
+      // That shouldn't happen, but if it does, try to recover.
+      LOG(ERROR) << "Failed to use a fallback temporary directory.";
+
+      // We're screwed if this fails, see CHECK above.
+      CHECK(temp_dir_.Set(system_tmp_dir));
+    }
+  }
+}
+
 void TestingProfile::Init() {
   if (!file_util::PathExists(profile_path_))
     file_util::CreateDirectory(profile_path_);
 
   extensions::ExtensionSystemFactory::GetInstance()->SetTestingFactory(
       this, extensions::TestExtensionSystem::Build);
 
   profile_dependency_manager_->CreateProfileServices(this, true);
 
 #if defined(ENABLE_NOTIFICATIONS)
@@ skipping 254 matching lines @@
   return HistoryServiceFactory::GetForProfileWithoutCreating(this);
 }
 
 net::CookieMonster* TestingProfile::GetCookieMonster() {
   if (!GetRequestContext())
     return NULL;
   return GetRequestContext()->GetURLRequestContext()->cookie_store()->
       GetCookieMonster();
 }
 
+policy::UserCloudPolicyManager* TestingProfile::GetUserCloudPolicyManager() {
+  return user_cloud_policy_manager_.get();
+}
+
 policy::PolicyService* TestingProfile::GetPolicyService() {
   if (!policy_service_.get()) {
 #if defined(ENABLE_CONFIGURATION_POLICY)
     policy::PolicyServiceImpl::Providers providers;
     policy_service_.reset(new policy::PolicyServiceImpl(providers));
 #else
     policy_service_.reset(new policy::PolicyServiceStub());
 #endif
   }
   return policy_service_.get();
@@ skipping 218 matching lines @@
 }
 
 bool TestingProfile::WasCreatedByVersionOrLater(const std::string& version) {
   return true;
 }
 
 base::Callback<ChromeURLDataManagerBackend*(void)>
     TestingProfile::GetChromeURLDataManagerBackendGetter() const {
   return base::Callback<ChromeURLDataManagerBackend*(void)>();
 }
+
+TestingProfile::Builder::Builder()
+    : build_called_(false),
+      delegate_(NULL) {
+}
+
+TestingProfile::Builder::~Builder() {
+}
+
+void TestingProfile::Builder::SetPath(const FilePath& path) {
+  path_ = path;
+}
+
+void TestingProfile::Builder::SetDelegate(Delegate* delegate) {
+  delegate_ = delegate;
+}
+
+void TestingProfile::Builder::SetExtensionSpecialStoragePolicy(
+    scoped_refptr<ExtensionSpecialStoragePolicy> policy) {
+  extension_policy_ = policy;
+}
+
+void TestingProfile::Builder::SetPrefService(scoped_ptr<PrefService> prefs) {
+  pref_service_ = prefs.Pass();
+}
+
+void TestingProfile::Builder::SetUserCloudPolicyManager(
+    scoped_ptr<policy::UserCloudPolicyManager> manager) {
+  user_cloud_policy_manager_ = manager.Pass();
+}
+
+scoped_ptr<TestingProfile> TestingProfile::Builder::Build() {
+  DCHECK(!build_called_);
+  build_called_ = true;
+  return scoped_ptr<TestingProfile>(new TestingProfile(
+      path_,
+      delegate_,
+      extension_policy_,
+      pref_service_.Pass(),
+      user_cloud_policy_manager_.Pass()));
+}
+
+