Change scoped_ptr to std::unique_ptr in //net.

net/sdch/sdch_owner.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 NET_SDCH_SDCH_OWNER_H_
 #define NET_SDCH_SDCH_OWNER_H_
 
 #include <stddef.h>
 #include <stdint.h>
 
@@ skipping 52 matching lines @@
 
     virtual ~PrefStorage();
 
     // Returns the read error if any. Valid to be called after initialization
     // is complete (see IsInitializationComplete).
     virtual ReadError GetReadError() const = 0;
 
     // Gets or sets the value in the preferences store.
     virtual bool GetValue(const base::DictionaryValue** result) const = 0;
     virtual bool GetMutableValue(base::DictionaryValue** result) = 0;
-    virtual void SetValue(scoped_ptr<base::DictionaryValue> value) = 0;
+    virtual void SetValue(std::unique_ptr<base::DictionaryValue> value) = 0;
 
     // Notifies the storage system that a value was changed via mutating the
     // result of GetMutableValue().
     virtual void ReportValueChanged() = 0;
 
     // Returns true if the store's init is complete. See the Start/Stop
     // functions below for observing changes to this value.
     virtual bool IsInitializationComplete() = 0;
 
     // Starts and stops observing preferences storage init. There will only
     // be one observer active at a time. The store should call
     // OnPrefStorageInitializationComplete() when it transitions to initialized
     // and there is an observer active. See also IsInitializationComplete().
     virtual void StartObservingInit(SdchOwner* observer) = 0;
     virtual void StopObservingInit() = 0;
   };
 
   static const size_t kMaxTotalDictionarySize;
   static const size_t kMinSpaceForDictionaryFetch;
 
   // Consumer must guarantee that |sdch_manager| and |context| outlive
   // this object.
   SdchOwner(SdchManager* sdch_manager, URLRequestContext* context);
   ~SdchOwner() override;
 
   // Enables use of pref persistence. Ownership of the storage will be passed.
   // This routine may only be called once per SdchOwner instance.
-  void EnablePersistentStorage(scoped_ptr<PrefStorage> pref_store);
+  void EnablePersistentStorage(std::unique_ptr<PrefStorage> pref_store);
 
   // Defaults to kMaxTotalDictionarySize.
   void SetMaxTotalDictionarySize(size_t max_total_dictionary_size);
 
   // Defaults to kMinSpaceForDictionaryFetch.
   void SetMinSpaceForDictionaryFetch(size_t min_space_for_dictionary_fetch);
 
   // SdchObserver implementation.
   void OnDictionaryAdded(const GURL& dictionary_url,
                          const std::string& server_hash) override;
@@ skipping 12 matching lines @@
   // gotten the dictionary.  The first two arguments are bound locally.
   // Public for testing.
   void OnDictionaryFetched(base::Time last_used,
                            base::Time created_time,
                            int use_count,
                            const std::string& dictionary_text,
                            const GURL& dictionary_url,
                            const BoundNetLog& net_log,
                            bool was_from_cache);
 
-  void SetClockForTesting(scoped_ptr<base::Clock> clock);
+  void SetClockForTesting(std::unique_ptr<base::Clock> clock);
 
   // Returns the total number of dictionaries loaded.
   int GetDictionaryCountForTesting() const;
 
   // Returns whether this SdchOwner has dictionary from |url| loaded.
   bool HasDictionaryFromURLForTesting(const GURL& url) const;
 
-  void SetFetcherForTesting(scoped_ptr<SdchDictionaryFetcher> fetcher);
+  void SetFetcherForTesting(std::unique_ptr<SdchDictionaryFetcher> fetcher);
 
  private:
   // For each active dictionary, stores local info.
   // Indexed by the server hash of the dictionary.
   struct DictionaryInfo {
     base::Time last_used;
     int use_count;
     size_t size;
 
     DictionaryInfo() : use_count(0), size(0) {}
@@ skipping 55 matching lines @@
   void RecordDictionaryFate(DictionaryFate fate);
 
   // Record the lifetime memory use of a specified dictionary, identified by
   // server hash.
   void RecordDictionaryEvictionOrUnload(
       const std::string& server_hash,
       size_t size,
       int use_count, DictionaryFate fate);
 
   net::SdchManager* manager_;
-  scoped_ptr<net::SdchDictionaryFetcher> fetcher_;
+  std::unique_ptr<net::SdchDictionaryFetcher> fetcher_;
 
   size_t total_dictionary_bytes_;
 
-  scoped_ptr<base::Clock> clock_;
+  std::unique_ptr<base::Clock> clock_;
 
   size_t max_total_dictionary_size_;
   size_t min_space_for_dictionary_fetch_;
 
   base::MemoryPressureListener memory_pressure_listener_;
 
   // Dictionary persistence machinery.
   // * |in_memory_pref_store_| is created on construction and used in the
   //   absence of any call to EnablePersistentStorage().
   // * |external_pref_store_| holds the preference store specified by
   //   EnablePersistentStorage() (if any).
   // * The external pref store is initialized asynchronously. During this time,
   //   both pointers will be value, pref_store_ will point to the in-memory
   //   one, and this class will be observing the initialization of the external
   //   store.
   // * When the external pref store is initialized, the in-memory version will
   //   be freed, and pref_store_ will point to the external one.
   // * |pref_store_| holds an unowned pointer to the currently
   //   active pref store (one of the preceding two).
-  scoped_ptr<PrefStorage> in_memory_pref_store_;
-  scoped_ptr<PrefStorage> external_pref_store_;
+  std::unique_ptr<PrefStorage> in_memory_pref_store_;
+  std::unique_ptr<PrefStorage> external_pref_store_;
   PrefStorage* pref_store_;
 
   // The use counts of dictionaries when they were loaded from the persistent
   // store, keyed by server hash. These are stored to avoid generating
   // misleading ever-increasing use counts for dictionaries that are persisted,
   // since the UMA histogram for use counts is only supposed to be since last
   // load.
   std::map<std::string, int> use_counts_at_load_;
 
   // Load times for loaded dictionaries, keyed by server hash. These are used to
   // track the durations that dictionaries are in memory.
   std::map<std::string, base::Time> load_times_;
 
   // Byte-seconds consumed by dictionaries that have been unloaded. These are
   // stored for later uploading in the SdchOwner destructor.
   std::vector<int64_t> consumed_byte_seconds_;
 
   // Creation time for this SdchOwner object, used for reporting temporal memory
   // pressure.
   base::Time creation_time_;
 
   DISALLOW_COPY_AND_ASSIGN(SdchOwner);
 };
 
 }  // namespace net
 
 #endif  // NET_SDCH_SDCH_OWNER_H_