Profiles: Really fix refcounted services.

chrome/browser/profiles/refcounted_profile_keyed_service_factory.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_BROWSER_PROFILES_REFCOUNTED_PROFILE_KEYED_SERVICE_FACTORY_H_
 #define CHROME_BROWSER_PROFILES_REFCOUNTED_PROFILE_KEYED_SERVICE_FACTORY_H_
 
 #include "base/basictypes.h"
 #include "base/compiler_specific.h"
 #include "base/memory/ref_counted.h"
 #include "chrome/browser/profiles/profile_keyed_service_factory.h"
 #include "chrome/browser/profiles/refcounted_profile_keyed_service.h"
 
 class Profile;
 class RefcountedProfileKeyedService;
 
 // A specialized ProfileKeyedServiceFactory that manages a
 // RefcountedThreadSafe<>.
 //
 // While the factory returns RefcountedThreadSafe<>s, the factory itself is a
 // base::NotThreadSafe. Only call methods on this object on the UI thread.
 //
 // Implementers of RefcountedProfileKeyedService should note that we guarantee
 // that ShutdownOnUIThread() is called on the UI thread, but actual object
 // destruction can happen anywhere.
 class RefcountedProfileKeyedServiceFactory : public ProfileKeyedBaseFactory {
+ public:
+  // A function that replaces the (possibly internal) object used by this
+  // factory. For the majority of cases, this is the object returned to users.

[Miranda Callahan, 2012/03/15 16:55:35]

As before: "Shouldn't FactoryFunction be described as "A function that takes a
Profile* and returns the PKS associated with that Profile"? I'm not sure what
you mean by "replaces the (possibly internal) object used by this factory" wrt
this function definition."

+  typedef scoped_refptr<RefcountedProfileKeyedService>
+      (*FactoryFunction)(Profile* profile);
+
+  // Associates |factory| with |profile| so that |factory| is used to create
+  // the ProfileKeyedService when requested.
+  //

[Miranda Callahan, 2012/03/15 16:55:35]

nit: remove blank line.

+  // |factory| can be NULL to signal that ProfileKeyedService should be NULL. A
+  // second call to SetTestingFactory() is allowed. If the FactoryFunction is

[Miranda Callahan, 2012/03/15 16:55:35]

nit as before: instead of "a second call", maybe "multiple calls ... are
allowed." 

+  // changed AND an instance of the PKSF already exists for |profile|, that
+  // service is destroyed.
+  void SetTestingFactory(Profile* profile, FactoryFunction factory);
+
+  // Associates |factory| with |profile| and immediately returns the created
+  // ProfileKeyedService. Since the factory will be used immediately, it may
+  // not be NULL;

[Miranda Callahan, 2012/03/15 16:55:35]

nit: s/;/./

+  scoped_refptr<RefcountedProfileKeyedService> SetTestingFactoryAndUse(
+      Profile* profile,
+      FactoryFunction factory);
+
  protected:
   RefcountedProfileKeyedServiceFactory(const char* name,
                                        ProfileDependencyManager* manager);
   virtual ~RefcountedProfileKeyedServiceFactory();
 
+  scoped_refptr<RefcountedProfileKeyedService> GetServiceForProfile(
+      Profile* profile,
+      bool create);
+
   // All subclasses of RefcountedProfileKeyedServiceFactory must return a
   // RefcountedProfileKeyedService instead of just a ProfileKeyedBase.
-  virtual RefcountedProfileKeyedService* BuildServiceInstanceFor(
+  virtual scoped_refptr<RefcountedProfileKeyedService> BuildServiceInstanceFor(
       Profile* profile) const = 0;
 
-  virtual void Associate(Profile* profile,
-                         ProfileKeyedBase* base) OVERRIDE;
-  virtual bool GetAssociation(Profile* profile,
-                              ProfileKeyedBase** out) const OVERRIDE;
   virtual void ProfileShutdown(Profile* profile) OVERRIDE;
   virtual void ProfileDestroyed(Profile* profile) OVERRIDE;
+  virtual void SetEmptyTestingFactory(Profile* profile) OVERRIDE;
+  virtual void CreateServiceNow(Profile* profile) OVERRIDE;
 
  private:
   typedef std::map<Profile*, scoped_refptr<RefcountedProfileKeyedService> >
       RefCountedStorage;
 
   // The mapping between a Profile and its refcounted service.
   RefCountedStorage mapping_;
 
+  // The mapping between a Profile and its overridden FactoryFunction.
+  std::map<Profile*, FactoryFunction> factories_;
+
   DISALLOW_COPY_AND_ASSIGN(RefcountedProfileKeyedServiceFactory);
 };
 
 #endif  // CHROME_BROWSER_PROFILES_REFCOUNTED_PROFILE_KEYED_SERVICE_FACTORY_H_