Convert //components/[f-n]* from scoped_ptr to std::unique_ptr

components/keyed_service/ios/browser_state_keyed_service_factory.h

 // Copyright 2014 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 COMPONENTS_KEYED_SERVICE_IOS_BROWSER_STATE_KEYED_SERVICE_FACTORY_H_
 #define COMPONENTS_KEYED_SERVICE_IOS_BROWSER_STATE_KEYED_SERVICE_FACTORY_H_
 
+#include <memory>
+
 #include "base/compiler_specific.h"
 #include "base/macros.h"
-#include "base/memory/scoped_ptr.h"
 #include "components/keyed_service/core/keyed_service_export.h"
 #include "components/keyed_service/core/keyed_service_factory.h"
 
 class BrowserStateDependencyManager;
 class KeyedService;
 
 namespace web {
 class BrowserState;
 }
 
 // Base class for Factories that take a BrowserState 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).
 //
 // 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 KEYED_SERVICE_EXPORT BrowserStateKeyedServiceFactory
     : public KeyedServiceFactory {
  public:
   // A function that supplies the instance of a KeyedService for a given
   // BrowserState. This is used primarily for testing, where we want to feed
   // a specific mock into the BSKSF system.
-  typedef scoped_ptr<KeyedService>(*TestingFactoryFunction)(
-      web::BrowserState* context);
+  using TestingFactoryFunction =
+      std::unique_ptr<KeyedService> (*)(web::BrowserState* context);
 
   // Associates |factory| with |context| so that |factory| is used to create
   // the KeyedService when requested.  |factory| can be NULL to signal that
   // KeyedService should be NULL. Multiple calls to SetTestingFactory() are
   // allowed; previous services will be shut down.
   void SetTestingFactory(web::BrowserState* context,
                          TestingFactoryFunction factory);
 
   // Associates |factory| with |context| and immediately returns the created
   // KeyedService. Since the factory will be used immediately, it may not be
@@ skipping 37 matching lines @@
   // You can override this so that by default, the service associated with the
   // TestingBrowserState is NULL. (This is just a shortcut around
   // SetTestingFactory() to make sure our contexts don't directly refer to the
   // services they use.)
   bool ServiceIsNULLWhileTesting() const override;
 
   // Interface for people building a type of BrowserStateKeyedFactory: -------
 
   // All subclasses of BrowserStateKeyedServiceFactory must return a
   // KeyedService instead of just a BrowserStateKeyedBase.
-  virtual scoped_ptr<KeyedService> BuildServiceInstanceFor(
+  virtual std::unique_ptr<KeyedService> BuildServiceInstanceFor(
       web::BrowserState* context) const = 0;
 
   // A helper object actually listens for notifications about BrowserState
   // destruction, calculates the order in which things are destroyed and then
   // does a two pass shutdown.
   //
   // First, BrowserStateShutdown() is called on every ServiceFactory and will
   // usually call KeyedService::Shutdown(), which gives each
   // KeyedService a chance to remove dependencies on other
   // services that it may be holding.
   //
   // Secondly, BrowserStateDestroyed() is called on every ServiceFactory
   // and the default implementation removes it from |mapping_| and deletes
   // the pointer.
   virtual void BrowserStateShutdown(web::BrowserState* context);
   virtual void BrowserStateDestroyed(web::BrowserState* context);
 
  private:
   // Registers any user preferences on this service. This is called by
   // RegisterPrefsIfNecessaryForContext() and should be overriden by any service
   // that wants to register profile-specific preferences.
   virtual void RegisterBrowserStatePrefs(
       user_prefs::PrefRegistrySyncable* registry) {}
 
   // KeyedServiceFactory:
-  scoped_ptr<KeyedService> BuildServiceInstanceFor(
+  std::unique_ptr<KeyedService> BuildServiceInstanceFor(
       base::SupportsUserData* context) const final;
   bool IsOffTheRecord(base::SupportsUserData* context) const final;
 
   // KeyedServiceBaseFactory:
   base::SupportsUserData* GetContextToUse(
       base::SupportsUserData* context) const final;
   bool ServiceIsCreatedWithContext() const final;
   void ContextShutdown(base::SupportsUserData* context) final;
   void ContextDestroyed(base::SupportsUserData* context) final;
   void RegisterPrefs(user_prefs::PrefRegistrySyncable* registry) final;
 
   DISALLOW_COPY_AND_ASSIGN(BrowserStateKeyedServiceFactory);
 };
 
 #endif  // COMPONENTS_KEYED_SERVICE_IOS_BROWSER_STATE_KEYED_SERVICE_FACTORY_H_