Profile shouldn't own DesktopNotificationService.

chrome/browser/profiles/profile_keyed_service_factory.h

 // Copyright (c) 2011 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_PROFILE_KEYED_SERVICE_FACTORY_H_
 #define CHROME_BROWSER_PROFILES_PROFILE_KEYED_SERVICE_FACTORY_H_
 
 #include <map>
 
 class Profile;
 class ProfileDependencyManager;
 class ProfileKeyedService;
 
 // Base class for Factories that take a Profile object and return some service
 // on a one-to-one mapping. Each factory that derives from this class *must*
 // be a Singleton (only unit tests don't do that). See ThemeServiceFactory as
 // an example of how to derive from this class.
 //
 // We do this because services depend on each other and we need to control
 // shutdown/destruction order. In each derived classes' constructors, the
 // implementors must explicitly state which services are depended on.
 class ProfileKeyedServiceFactory {
+ public:
+  typedef ProfileKeyedService* (*FactoryFunction)(Profile* profile);
+
+#if defined(UNIT_TEST)
+  // Associate an already-created |service| with |profile| for this factory.
+  // The service may be a mock, or may be NULL to inhibit automatic creation of
+  // the service by the default function. A mock factory set with
+  // |set_test_factory| will be called instead if the service is NULL.
+  void ForceAssociationBetween(Profile* profile, ProfileKeyedService* service) {
+    Associate(profile, service);
+  }
+
+  // Sets the factory function to use to create mock instances of this service.
+  // The factory function will only be called for profiles for which
+  // |ForceAssociationBetween| has been previously called with a NULL service
+  // pointer, and therefore does not affect normal non-test profiles.
+  void set_test_factory(FactoryFunction factory) { factory_ = factory; }
+#endif
+
  protected:
-  friend class ProfileDependencyManager;
-  friend class ProfileDependencyManagerUnittests;
-
   // ProfileKeyedServiceFactories must communicate with a
   // ProfileDependencyManager. For all non-test code, write your subclass
   // constructors like this:
   //
   //   MyServiceFactory::MyServiceFactory()
   //     : ProfileKeyedServiceFactory(
   //         ProfileDependencyManager::GetInstance())
   //   {}
   explicit ProfileKeyedServiceFactory(ProfileDependencyManager* manager);
   virtual ~ProfileKeyedServiceFactory();
@@ skipping 30 matching lines @@
   // usually call ProfileKeyedService::Shutdown(), which gives each
   // ProfileKeyedService a chance to remove dependencies on other services that
   // it may be holding.
   //
   // Secondly, ProfileDestroyed() is called on every ServiceFactory and the
   // default implementation removes it from |mapping_| and deletes the pointer.
   virtual void ProfileShutdown(Profile* profile);
   virtual void ProfileDestroyed(Profile* profile);
 
  private:
+  friend class ProfileDependencyManager;
+  friend class ProfileDependencyManagerUnittests;
+
   // The mapping between a Profile and its service.
   std::map<Profile*, ProfileKeyedService*> mapping_;
 
   // Which ProfileDependencyManager we should communicate with. In real code,
   // this will always be ProfileDependencyManager::GetInstance(), but unit
   // tests will want to use their own copy.
   ProfileDependencyManager* dependency_manager_;
+
+  // A mock factory function to use to create the service, used by tests.
+  FactoryFunction factory_;
 };
 
 #endif  // CHROME_BROWSER_PROFILES_PROFILE_KEYED_SERVICE_FACTORY_H_