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

net/sdch/sdch_owner.cc

 // 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.
 
 #include "net/sdch/sdch_owner.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/debug/alias.h"
 #include "base/logging.h"
 #include "base/macros.h"
+#include "base/memory/ptr_util.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/strings/string_util.h"
 #include "base/time/default_clock.h"
 #include "base/values.h"
 #include "net/base/sdch_manager.h"
 #include "net/base/sdch_net_log_params.h"
 
 namespace net {
 
 namespace {
@@ skipping 49 matching lines @@
   ReadError GetReadError() const override { return PERSISTENCE_FAILURE_NONE; }
 
   bool GetValue(const base::DictionaryValue** result) const override {
     *result = &storage_;
     return true;
   }
   bool GetMutableValue(base::DictionaryValue** result) override {
     *result = &storage_;
     return true;
   }
-  void SetValue(scoped_ptr<base::DictionaryValue> value) override {
+  void SetValue(std::unique_ptr<base::DictionaryValue> value) override {
     storage_.Clear();
     storage_.MergeDictionary(value.get());
   }
 
   void ReportValueChanged() override {}
 
   // This storage class requires no special initialization.
   bool IsInitializationComplete() override { return true; }
   void StartObservingInit(SdchOwner* observer) override {}
   void StopObservingInit() override {}
@@ skipping 19 matching lines @@
   DCHECK(success);
   DCHECK(dictionary_list_dictionary);
 
   return dictionary_list_dictionary;
 }
 
 // This function initializes a pref store with an empty version of the
 // above schema, removing anything previously in the store under
 // kPreferenceName.
 void InitializePrefStore(SdchOwner::PrefStorage* store) {
-  scoped_ptr<base::DictionaryValue> empty_store(new base::DictionaryValue);
+  std::unique_ptr<base::DictionaryValue> empty_store(new base::DictionaryValue);
   empty_store->SetInteger(kVersionKey, kVersion);
   empty_store->Set(kDictionariesKey,
-                   make_scoped_ptr(new base::DictionaryValue));
+                   base::WrapUnique(new base::DictionaryValue));
   store->SetValue(std::move(empty_store));
 }
 
 // A class to allow iteration over all dictionaries in the pref store, and
 // easy lookup of the information associated with those dictionaries.
 // Note that this is an "Iterator" in the same sense (and for the same
 // reasons) that base::Dictionary::Iterator is an iterator--it allows
 // iterating over all the dictionaries in the preference store, but it
 // does not allow use as an STL iterator because the container it
 // is iterating over does not export begin()/end() methods. This iterator can
@@ skipping 195 matching lines @@
   for (const auto& val : consumed_byte_seconds_) {
     if (object_lifetime > 0) {
       // Objects that are created and immediately destroyed don't add any memory
       // pressure over time (and also cause a crash here).
       UMA_HISTOGRAM_MEMORY_KB("Sdch3.TimeWeightedMemoryUse",
                               val / object_lifetime);
     }
   }
 }
 
-void SdchOwner::EnablePersistentStorage(scoped_ptr<PrefStorage> pref_store) {
+void SdchOwner::EnablePersistentStorage(
+    std::unique_ptr<PrefStorage> pref_store) {
   DCHECK(!external_pref_store_);
   DCHECK(pref_store);
   external_pref_store_ = std::move(pref_store);
   external_pref_store_->StartObservingInit(this);
 
   if (external_pref_store_->IsInitializationComplete())
     OnPrefStorageInitializationComplete(true);
 }
 
 void SdchOwner::SetMaxTotalDictionarySize(size_t max_total_dictionary_size) {
@@ skipping 124 matching lines @@
 
   // If a dictionary has never been used, its dictionary addition time
   // is recorded as its last used time.  Never used dictionaries are treated
   // specially in the freshness logic.
   if (last_used.is_null())
     last_used = clock_->Now();
 
   total_dictionary_bytes_ += dictionary_text.size();
 
   // Record the addition in the pref store.
-  scoped_ptr<base::DictionaryValue> dictionary_description(
+  std::unique_ptr<base::DictionaryValue> dictionary_description(
       new base::DictionaryValue());
   dictionary_description->SetString(kDictionaryUrlKey, dictionary_url.spec());
   dictionary_description->SetDouble(kDictionaryLastUsedKey,
                                     last_used.ToDoubleT());
   dictionary_description->SetDouble(kDictionaryCreatedTimeKey,
                                     created_time.ToDoubleT());
   dictionary_description->SetInteger(kDictionaryUseCountKey, use_count);
   dictionary_description->SetInteger(kDictionarySizeKey,
                                      dictionary_text.size());
   pref_dictionary_map->Set(server_hash, std::move(dictionary_description));
@@ skipping 136 matching lines @@
   GetPersistentStoreDictionaryMap(external_pref_store_.get())
       ->Swap(GetPersistentStoreDictionaryMap(in_memory_pref_store_.get()));
 
   // This object can stop waiting on (i.e. observing) the external preference
   // store and switch over to using it as the primary preference store.
   pref_store_ = external_pref_store_.get();
   external_pref_store_->StopObservingInit();
   in_memory_pref_store_ = nullptr;
 }
 
-void SdchOwner::SetClockForTesting(scoped_ptr<base::Clock> clock) {
+void SdchOwner::SetClockForTesting(std::unique_ptr<base::Clock> clock) {
   clock_ = std::move(clock);
 }
 
 int SdchOwner::GetDictionaryCountForTesting() const {
   int count = 0;
   for (DictionaryPreferenceIterator it(pref_store_); !it.IsAtEnd();
        it.Advance()) {
     count++;
   }
   return count;
 }
 
 bool SdchOwner::HasDictionaryFromURLForTesting(const GURL& url) const {
   for (DictionaryPreferenceIterator it(pref_store_); !it.IsAtEnd();
        it.Advance()) {
     if (it.url() == url)
       return true;
   }
   return false;
 }
 
 void SdchOwner::SetFetcherForTesting(
-    scoped_ptr<SdchDictionaryFetcher> fetcher) {
+    std::unique_ptr<SdchDictionaryFetcher> fetcher) {
   fetcher_ = std::move(fetcher);
 }
 
 void SdchOwner::OnMemoryPressure(
     base::MemoryPressureListener::MemoryPressureLevel level) {
   DCHECK_NE(base::MemoryPressureListener::MEMORY_PRESSURE_LEVEL_NONE, level);
 
   for (DictionaryPreferenceIterator it(pref_store_); !it.IsAtEnd();
        it.Advance()) {
     int new_uses = it.use_count() - use_counts_at_load_[it.server_hash()];
@@ skipping 59 matching lines @@
   }
 
   return true;
 }
 
 bool SdchOwner::IsPersistingDictionaries() const {
   return in_memory_pref_store_.get() != nullptr;
 }
 
 }  // namespace net