Convert UserPolicySigninService to use OAuth2TokenService

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/files/scoped_temp_dir.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "chrome/browser/profiles/profile.h"
+#include "components/browser_context_keyed_service/browser_context_keyed_service_factory.h"
 
 namespace content {
 class MockResourceContext;
 }
 
 namespace extensions {
 class ExtensionPrefs;
 }
 
 namespace history {
@@ skipping 28 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();
 
+  typedef std::vector<std::pair<
+      BrowserContextKeyedServiceFactory*,
+      BrowserContextKeyedServiceFactory::FactoryFunction> > TestingFactories;
+
   // 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
+    // Sets a Delegate to be called back during profile init. 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);
 
+    // Adds a testing factory to the TestingProfile. These testing factories
+    // are applied before the ProfileKeyedServices are created.
+    void AddTestingFactory(
+        BrowserContextKeyedServiceFactory* service_factory,
+        BrowserContextKeyedServiceFactory::FactoryFunction callback);
+
     // 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 base::FilePath& path);
 
     // Sets the PrefService to be used by this profile.
     void SetPrefService(scoped_ptr<PrefServiceSyncable> prefs);
 
+    // Makes the Profile being built an incognito profile.
+    void SetIncognito();
+
     // 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<PrefServiceSyncable> pref_service_;
     scoped_refptr<ExtensionSpecialStoragePolicy> extension_policy_;
     base::FilePath path_;
     Delegate* delegate_;
+    bool incognito_;
+    TestingFactories testing_factories_;
 
     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 base::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 base::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 base::FilePath& path,
                  Delegate* delegate,
                  scoped_refptr<ExtensionSpecialStoragePolicy> extension_policy,
-                 scoped_ptr<PrefServiceSyncable> prefs);
+                 scoped_ptr<PrefServiceSyncable> prefs,
+                 bool incognito,
+                 const TestingFactories& factories);
 
   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,
@@ skipping 45 matching lines @@
       content::ProtocolHandlerMap* protocol_handlers) OVERRIDE;
   virtual net::URLRequestContextGetter* GetRequestContextForRenderProcess(
       int renderer_child_id) OVERRIDE;
   virtual content::ResourceContext* GetResourceContext() OVERRIDE;
   virtual content::GeolocationPermissionContext*
       GetGeolocationPermissionContext() OVERRIDE;
   virtual quota::SpecialStoragePolicy* GetSpecialStoragePolicy() OVERRIDE;
 
   virtual TestingProfile* AsTestingProfile() OVERRIDE;
   virtual std::string GetProfileName() OVERRIDE;
-  void set_incognito(bool incognito) { incognito_ = incognito; }
+
+  // DEPRECATED, because it's fragile to change a profile from non-incognito
+  // to incognito after the ProfileKeyedServices have been created (some
+  // ProfileKeyedServices either should not exist in incognito mode, or will
+  // crash when they try to get references to other services they depend on,
+  // but do not exist in incognito mode).
+  // TODO(atwilson): Remove this API (http://crbug.com/277296).
+  //
+  // Changes a profile's to/from incognito mode temporarily - profile will be
+  // returned to non-incognito before destruction to allow services to
+  // properly shutdown. This is only supported for legacy tests - new tests
+  // should create a true incognito profile using Builder::SetIncognito() or
+  // by using the TestingProfile constructor that allows setting the incognito
+  // flag.
+  void ForceIncognito(bool force_incognito) {
+    force_incognito_ = force_incognito;
+  }
+
   // Assumes ownership.
-  virtual void SetOffTheRecordProfile(Profile* profile);
+  virtual void SetOffTheRecordProfile(scoped_ptr<Profile> profile);
   virtual void SetOriginalProfile(Profile* profile);
   virtual Profile* GetOffTheRecordProfile() OVERRIDE;
   virtual void DestroyOffTheRecordProfile() OVERRIDE {}
   virtual bool HasOffTheRecordProfile() OVERRIDE;
   virtual Profile* GetOriginalProfile() OVERRIDE;
   virtual bool IsManaged() OVERRIDE;
   virtual ExtensionService* GetExtensionService() OVERRIDE;
   void SetExtensionSpecialStoragePolicy(
       ExtensionSpecialStoragePolicy* extension_special_storage_policy);
   virtual ExtensionSpecialStoragePolicy*
@@ skipping 97 matching lines @@
   // maps to this profile.
   void CreateProfilePolicyConnector();
 
   // Internally, this is a TestURLRequestContextGetter that creates a dummy
   // request context. Currently, only the CookieMonster is hooked up.
   scoped_refptr<net::URLRequestContextGetter> extensions_request_context_;
 
   std::wstring id_;
 
   bool incognito_;
+  bool force_incognito_;
   scoped_ptr<Profile> incognito_profile_;
   Profile* original_profile_;
 
   // Did the last session exit cleanly? Default is true.
   bool last_session_exited_cleanly_;
 
   scoped_refptr<HostContentSettingsMap> host_content_settings_map_;
 
   base::FilePath last_selected_directory_;
   scoped_refptr<history::TopSites> top_sites_;  // For history and thumbnails.
@@ skipping 21 matching lines @@
   // scoped_ptr<>.
   content::MockResourceContext* resource_context_;
 
   scoped_ptr<policy::ProfilePolicyConnector> profile_policy_connector_;
 
   // Weak pointer to a delegate for indicating that a profile was created.
   Delegate* delegate_;
 };
 
 #endif  // CHROME_TEST_BASE_TESTING_PROFILE_H_