Add support for loading user cloud policy on desktop.

chrome/test/base/testing_profile.h

 // 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.
 
 #ifndef CHROME_TEST_BASE_TESTING_PROFILE_H_
 #define CHROME_TEST_BASE_TESTING_PROFILE_H_
 
 #include <string>
 
 #include "base/memory/ref_counted.h"
@@ skipping 40 matching lines @@
   // platforms but must be different on ChromeOS because a logged-in user cannot
   // use "Default" as profile directory.
   // Browser- and UI tests should always use this to get to the user's profile
   // directory. Unit-tests, though, should use |kInitialProfile|, which is
   // always "Default", because they are runnining without logged-in user.
   static const char kTestUserProfileDir[];
 
   // Default constructor that cannot be used with multi-profiles.
   TestingProfile();
 
+  // Helper class for building an instance of TestingProfile (allows injecting
+  // mocks for various services prior to profile initialization).
+  // TODO(atwilson): Remove non-default constructors and various setters in
+  // favor of using the Builder API.
+  class Builder {
+   public:
+    Builder();
+    ~Builder();
+
+    // Sets a Delegate to be called back when the Profile is fully initialized.
+    // This causes the final initialization to be performed via a task so the
+    // caller must run a MessageLoop. Caller maintains ownership of the Delegate
+    // and must manage its lifetime so it continues to exist until profile
+    // initialization is complete.
+    void SetDelegate(Delegate* delegate);
+
+    // Sets the ExtensionSpecialStoragePolicy to be returned by
+    // GetExtensionSpecialStoragePolicy().
+    void SetExtensionSpecialStoragePolicy(
+        scoped_refptr<ExtensionSpecialStoragePolicy> policy);
+
+    // Sets the path to the directory to be used to hold profile data.
+    void SetPath(const FilePath& path);
+
+    // Sets the PrefService to be used by this profile.
+    void SetPrefService(scoped_ptr<PrefService> prefs);
+
+    // Sets the UserCloudPolicyManager to be used by this profile.
+    void SetUserCloudPolicyManager(
+        scoped_ptr<policy::UserCloudPolicyManager> manager);
+
+    // Creates the TestingProfile using previously-set settings.
+    scoped_ptr<TestingProfile> Build();
+
+   private:
+    // If true, Build() has already been called.
+    bool build_called_;
+
+    // Various staging variables where values are held until Build() is invoked.
+    scoped_ptr<policy::UserCloudPolicyManager> user_cloud_policy_manager_;
+    scoped_ptr<PrefService> pref_service_;
+    scoped_refptr<ExtensionSpecialStoragePolicy> extension_policy_;
+    FilePath path_;
+    Delegate* delegate_;
+
+    DISALLOW_COPY_AND_ASSIGN(Builder);
+  };
+
   // Multi-profile aware constructor that takes the path to a directory managed
   // for this profile. This constructor is meant to be used by
   // TestingProfileManager::CreateTestingProfile. If you need to create multi-
   // profile profiles, use that factory method instead of this directly.
   // Exception: if you need to create multi-profile profiles for testing the
   // ProfileManager, then use the constructor below instead.
   explicit TestingProfile(const FilePath& path);
 
   // Multi-profile aware constructor that takes the path to a directory managed
   // for this profile and a delegate. This constructor is meant to be used
   // for unittesting the ProfileManager.
   TestingProfile(const FilePath& path, Delegate* delegate);
 
+  // Full constructor allowing the setting of all possible instance data.
+  // Callers should use Builder::Build() instead of invoking this constructor.
+  TestingProfile(const FilePath& path,

[sky, 2012/08/06 22:28:27]

We already have so many constructors in this class. It is possible to nuke this
and force creation to go through Build. Build in term would use one of the
existing constructors and set up whatever state it needs to.

[Andrew T Wilson (Slow), 2012/08/06 23:12:25]

I have a TODO to do exactly this (see above), but I want to do it in a separate
CL since this one is already too unwieldy.

[Andrew T Wilson (Slow), 2012/08/06 23:59:14]

To be clear, my intent is to remove all other constructors, have all use go
through Builder::Build(), and move this constructor to be private/only
accessible to Builder.

+                 Delegate* delegate,
+                 scoped_refptr<ExtensionSpecialStoragePolicy> extension_policy,
+                 scoped_ptr<PrefService> prefs,
+                 scoped_ptr<policy::UserCloudPolicyManager> manager);
+
   virtual ~TestingProfile();
 
   // Creates the favicon service. Consequent calls would recreate the service.
   void CreateFaviconService();
 
   // Creates the history service. If |delete_file| is true, the history file is
   // deleted first, then the HistoryService is created. As TestingProfile
   // deletes the directory containing the files used by HistoryService, this
   // only matters if you're recreating the HistoryService.  If |no_db| is true,
   // the history backend will fail to initialize its database; this is useful
@@ skipping 76 matching lines @@
       ExtensionSpecialStoragePolicy* extension_special_storage_policy);
   virtual ExtensionSpecialStoragePolicy*
       GetExtensionSpecialStoragePolicy() OVERRIDE;
   virtual FaviconService* GetFaviconService(ServiceAccessType access) OVERRIDE;
   virtual HistoryService* GetHistoryService(ServiceAccessType access) OVERRIDE;
   virtual HistoryService* GetHistoryServiceWithoutCreating() OVERRIDE;
   // The CookieMonster will only be returned if a Context has been created. Do
   // this by calling CreateRequestContext(). See the note at GetRequestContext
   // for more information.
   net::CookieMonster* GetCookieMonster();
+
+  virtual policy::UserCloudPolicyManager* GetUserCloudPolicyManager() OVERRIDE;
   virtual policy::PolicyService* GetPolicyService() OVERRIDE;
   // Sets the profile's PrefService. If a pref service hasn't been explicitly
   // set GetPrefs creates one, so normally you need not invoke this. If you need
   // to set a pref service you must invoke this before GetPrefs.
   // TestingPrefService takes ownership of |prefs|.
   void SetPrefService(PrefService* prefs);
   virtual PrefService* GetPrefs() OVERRIDE;
   virtual history::TopSites* GetTopSites() OVERRIDE;
   virtual history::TopSites* GetTopSitesWithoutCreating() OVERRIDE;
 
@@ skipping 55 matching lines @@
 
   virtual PrefService* GetOffTheRecordPrefs() OVERRIDE;
 
  protected:
   base::Time start_time_;
   scoped_ptr<PrefService> prefs_;
   // ref only for right type, lifecycle is managed by prefs_
   TestingPrefService* testing_prefs_;
 
  private:
+  // Creates a temporary directory for use by this profile.
+  void CreateTempProfileDir();
+
   // Common initialization between the two constructors.
   void Init();
 
   // Finishes initialization when a profile is created asynchronously.
   void FinishInit();
 
   // Destroys favicon service if it has been created.
   void DestroyFaviconService();
 
   // Creates a TestingPrefService and associates it with the TestingProfile.
@@ skipping 27 matching lines @@
 
   FilePath last_selected_directory_;
   scoped_refptr<history::TopSites> top_sites_;  // For history and thumbnails.
 
   scoped_refptr<ExtensionSpecialStoragePolicy>
       extension_special_storage_policy_;
 
   // The proxy prefs tracker.
   scoped_ptr<PrefProxyConfigTracker> pref_proxy_config_tracker_;
 
+  // UserCloudPolicyManager returned by GetUserCloudPolicyManager().
+  scoped_ptr<policy::UserCloudPolicyManager> user_cloud_policy_manager_;
+
   // We use a temporary directory to store testing profile data. In a multi-
   // profile environment, this is invalid and the directory is managed by the
   // TestingProfileManager.
   ScopedTempDir temp_dir_;
   // The path to this profile. This will be valid in either of the two above
   // cases.
   FilePath profile_path_;
 
   // We keep a weak pointer to the dependency manager we want to notify on our
   // death. Defaults to the Singleton implementation but overridable for
   // testing.
   ProfileDependencyManager* profile_dependency_manager_;
 
   scoped_ptr<content::MockResourceContext> resource_context_;
 
   // Weak pointer to a delegate for indicating that a profile was created.
   Delegate* delegate_;
 };
 
 #endif  // CHROME_TEST_BASE_TESTING_PROFILE_H_