components/password_manager: scoped_ptr -> unique_ptr

components/password_manager/core/browser/affiliation_backend.h

 // Copyright 2015 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_PASSWORD_MANAGER_CORE_BROWSER_AFFILIATION_BACKEND_H_
 #define COMPONENTS_PASSWORD_MANAGER_CORE_BROWSER_AFFILIATION_BACKEND_H_
 
 #include <stddef.h>
 
 #include <map>
@@ skipping 44 matching lines @@
  public:
   using StrategyOnCacheMiss = AffiliationService::StrategyOnCacheMiss;
 
   // Constructs an instance that will use |request_context_getter| for all
   // network requests, use |task_runner| for asynchronous tasks, and will rely
   // on |time_source| and |time_tick_source| to tell the current time/ticks.
   // Construction is very cheap, expensive steps are deferred to Initialize().
   AffiliationBackend(
       const scoped_refptr<net::URLRequestContextGetter>& request_context_getter,
       const scoped_refptr<base::SingleThreadTaskRunner>& task_runner,
-      scoped_ptr<base::Clock> time_source,
-      scoped_ptr<base::TickClock> time_tick_source);
+      std::unique_ptr<base::Clock> time_source,
+      std::unique_ptr<base::TickClock> time_tick_source);
   ~AffiliationBackend() override;
 
   // Performs the I/O-heavy part of initialization. The database used to cache
   // affiliation information locally will be opened/created at |db_path|.
   void Initialize(const base::FilePath& db_path);
 
   // Implementations for methods of the same name in AffiliationService. They
   // are not documented here again. See affiliation_service.h for details:
   void GetAffiliations(
       const FacetURI& facet_uri,
@@ skipping 32 matching lines @@
   // FacetManagerHost:
   bool ReadAffiliationsFromDatabase(
       const FacetURI& facet_uri,
       AffiliatedFacetsWithUpdateTime* affiliations) override;
   void SignalNeedNetworkRequest() override;
   void RequestNotificationAtTime(const FacetURI& facet_uri,
                                  base::Time time) override;
 
   // AffiliationFetcherDelegate:
   void OnFetchSucceeded(
-      scoped_ptr<AffiliationFetcherDelegate::Result> result) override;
+      std::unique_ptr<AffiliationFetcherDelegate::Result> result) override;
   void OnFetchFailed() override;
   void OnMalformedResponse() override;
 
   // AffiliationFetchThrottlerDelegate:
   bool OnCanSendNetworkRequest() override;
 
   // Returns the number of in-memory FacetManagers. Used only for testing.
   size_t facet_manager_count_for_testing() { return facet_managers_.size(); }
 
   // Reports the |requested_facet_uri_count| in a single fetch; and the elapsed
   // time before the first fetch, and in-between subsequent fetches.
   void ReportStatistics(size_t requested_facet_uri_count);
 
   // To be called after Initialize() to use |throttler| instead of the default
   // one. Used only for testing.
-  void SetThrottlerForTesting(scoped_ptr<AffiliationFetchThrottler> throttler);
+  void SetThrottlerForTesting(
+      std::unique_ptr<AffiliationFetchThrottler> throttler);
 
   // Created in Initialize(), and ensures that all subsequent methods are called
   // on the same thread.
-  scoped_ptr<base::ThreadChecker> thread_checker_;
+  std::unique_ptr<base::ThreadChecker> thread_checker_;
 
   scoped_refptr<net::URLRequestContextGetter> request_context_getter_;
   scoped_refptr<base::SingleThreadTaskRunner> task_runner_;
-  scoped_ptr<base::Clock> clock_;
-  scoped_ptr<base::TickClock> tick_clock_;
+  std::unique_ptr<base::Clock> clock_;
+  std::unique_ptr<base::TickClock> tick_clock_;
 
-  scoped_ptr<AffiliationDatabase> cache_;
-  scoped_ptr<AffiliationFetcher> fetcher_;
-  scoped_ptr<AffiliationFetchThrottler> throttler_;
+  std::unique_ptr<AffiliationDatabase> cache_;
+  std::unique_ptr<AffiliationFetcher> fetcher_;
+  std::unique_ptr<AffiliationFetchThrottler> throttler_;
 
   base::Time construction_time_;
   base::Time last_request_time_;
 
   // Contains a FacetManager for each facet URI that need ongoing attention. To
   // save memory, managers are discarded as soon as they become redundant.
-  base::ScopedPtrHashMap<FacetURI, scoped_ptr<FacetManager>> facet_managers_;
+  base::ScopedPtrHashMap<FacetURI, std::unique_ptr<FacetManager>>
+      facet_managers_;
 
   base::WeakPtrFactory<AffiliationBackend> weak_ptr_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(AffiliationBackend);
 };
 
 }  // namespace password_manager
 
 #endif  // COMPONENTS_PASSWORD_MANAGER_CORE_BROWSER_AFFILIATION_BACKEND_H_