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

net/sdch/sdch_owner_unittest.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/location.h"
 #include "base/macros.h"
 #include "base/memory/memory_pressure_listener.h"
+#include "base/memory/ptr_util.h"
 #include "base/run_loop.h"
 #include "base/single_thread_task_runner.h"
 #include "base/strings/stringprintf.h"
 #include "base/test/histogram_tester.h"
 #include "base/test/simple_test_clock.h"
 #include "base/thread_task_runner_handle.h"
 #include "base/values.h"
 #include "net/base/sdch_manager.h"
 #include "net/log/net_log.h"
 #include "net/url_request/url_request.h"
@@ skipping 62 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 initialized_; }
   void StartObservingInit(SdchOwner* observer) override {
     DCHECK(!initialization_observer_);
@@ skipping 222 matching lines @@
 
   int JobsRecentlyCreated() {
     int result = error_jobs_created - last_jobs_created_;
     last_jobs_created_ = error_jobs_created;
     return result;
   }
 
   bool DictionaryPresentInManager(const std::string& server_hash) {
     // Presumes all tests use generic url.
     SdchProblemCode tmp;
-    scoped_ptr<SdchManager::DictionarySet> set(
+    std::unique_ptr<SdchManager::DictionarySet> set(
         sdch_manager_.GetDictionarySetByHash(GURL(generic_url), server_hash,
                                              &tmp));
     return !!set.get();
   }
 
   void WaitForNoJobs() {
     if (outstanding_url_request_error_counting_jobs == 0)
       return;
 
     base::RunLoop run_loop;
@@ skipping 50 matching lines @@
   int last_jobs_created_;
   BoundNetLog net_log_;
   int dictionary_creation_index_;
 
   // The dependencies of these objects (sdch_owner_ -> {sdch_manager_,
   // url_request_context_}, url_request_context_->job_factory_) require
   // this order for correct destruction semantics.
   MockURLRequestJobFactory job_factory_;
   URLRequestContext url_request_context_;
   SdchManager sdch_manager_;
-  scoped_ptr<SdchOwner> sdch_owner_;
+  std::unique_ptr<SdchOwner> sdch_owner_;
 
   DISALLOW_COPY_AND_ASSIGN(SdchOwnerTest);
 };
 
 // Does OnGetDictionary result in a fetch when there's enough space, and not
 // when there's not?
 TEST_F(SdchOwnerTest, OnGetDictionary_Fetching) {
   GURL request_url(std::string(generic_url) + "/r1");
 
   // Fetch generated when empty.
@@ skipping 51 matching lines @@
 }
 
 // Confirm auto-eviction happens if space is needed.
 TEST_F(SdchOwnerTest, ConfirmAutoEviction) {
   base::Time start_time = base::Time::Now();
   std::string server_hash_d1;
   std::string server_hash_d2;
   std::string server_hash_d3;
 
   base::SimpleTestClock* test_clock = new base::SimpleTestClock();
-  sdch_owner().SetClockForTesting(make_scoped_ptr(test_clock));
+  sdch_owner().SetClockForTesting(base::WrapUnique(test_clock));
   test_clock->SetNow(base::Time::Now());
 
   // Add two dictionaries, one recent, one more than a day in the past.
   base::Time fresh(base::Time::Now() - base::TimeDelta::FromHours(23));
   base::Time stale(base::Time::Now() - base::TimeDelta::FromHours(25));
 
   EXPECT_TRUE(
       CreateAndAddDictionary(kMaxSizeForTesting / 2, fresh, &server_hash_d1));
   EXPECT_TRUE(
       CreateAndAddDictionary(kMaxSizeForTesting / 2, stale, &server_hash_d2));
@@ skipping 236 matching lines @@
   // Addition should now succeed.
   EXPECT_TRUE(
       CreateAndAddDictionary(kMaxSizeForTesting, base::Time::Now(), nullptr));
 }
 
 // Confirm that use of a pinned dictionary after its removal works properly.
 TEST_F(SdchOwnerTest, PinRemoveUse) {
   // Pass ownership of the storage to the SdchOwner, but keep a pointer.
   TestPrefStorage* pref_store = new TestPrefStorage(true);
   sdch_owner().EnablePersistentStorage(
-      scoped_ptr<SdchOwner::PrefStorage>(pref_store));
+      std::unique_ptr<SdchOwner::PrefStorage>(pref_store));
 
   std::string server_hash_d1;
   EXPECT_TRUE(CreateAndAddDictionary(kMaxSizeForTesting / 2, base::Time::Now(),
                                      &server_hash_d1));
 
-  scoped_ptr<SdchManager::DictionarySet> return_set(
+  std::unique_ptr<SdchManager::DictionarySet> return_set(
       sdch_manager().GetDictionarySet(
           GURL(std::string(generic_url) + "/x.html")));
   ASSERT_TRUE(return_set.get());
   EXPECT_TRUE(return_set->GetDictionaryText(server_hash_d1));
 
   const base::Value* result = nullptr;
   const base::DictionaryValue* dict_result = nullptr;
   ASSERT_TRUE(pref_store->GetValue(&dict_result));
   EXPECT_TRUE(dict_result->Get("dictionaries", &result));
   EXPECT_TRUE(dict_result->Get("dictionaries." + server_hash_d1, &result));
 
   sdch_manager().ClearData();
 
   ASSERT_TRUE(pref_store->GetValue(&dict_result));
   EXPECT_TRUE(dict_result->Get("dictionaries", &result));
   EXPECT_FALSE(dict_result->Get("dictionaries." + server_hash_d1, &result));
 
-  scoped_ptr<SdchManager::DictionarySet> return_set2(
+  std::unique_ptr<SdchManager::DictionarySet> return_set2(
       sdch_manager().GetDictionarySet(
           GURL(std::string(generic_url) + "/x.html")));
   EXPECT_FALSE(return_set2.get());
 
   sdch_manager().OnDictionaryUsed(server_hash_d1);
 
   ASSERT_TRUE(pref_store->GetValue(&dict_result));
   EXPECT_TRUE(dict_result->Get("dictionaries", &result));
   EXPECT_FALSE(dict_result->Get("dictionaries." + server_hash_d1, &result));
 }
@@ skipping 23 matching lines @@
  public:
   SdchOwnerPersistenceTest() {}
   virtual ~SdchOwnerPersistenceTest() {}
 
   void ClearOwner() {
     owner_.reset(NULL);
   }
 
   // If the storage points is non-null it will be saved as the persistent
   // storage for the SdchOwner.
-  void ResetOwner(scoped_ptr<SdchOwner::PrefStorage> storage) {
+  void ResetOwner(std::unique_ptr<SdchOwner::PrefStorage> storage) {
     // This has to be done first, since SdchOwner may be observing SdchManager,
     // and SdchManager can't be destroyed with a live observer.
     owner_.reset(NULL);
     manager_.reset(new SdchManager());
     fetcher_ = new MockSdchDictionaryFetcher();
     owner_.reset(new SdchOwner(manager_.get(),
                                &url_request_context_));
     owner_->SetMaxTotalDictionarySize(SdchOwnerTest::kMaxSizeForTesting);
     owner_->SetMinSpaceForDictionaryFetch(
         SdchOwnerTest::kMinFetchSpaceForTesting);
-    owner_->SetFetcherForTesting(make_scoped_ptr(fetcher_));
+    owner_->SetFetcherForTesting(base::WrapUnique(fetcher_));
     if (storage)
       owner_->EnablePersistentStorage(std::move(storage));
   }
 
   void InsertDictionaryForURL(const GURL& url, const std::string& nonce) {
     owner_->OnDictionaryFetched(base::Time::Now(), base::Time::Now(), 1,
                                 CreateDictionary(url, nonce), url, net_log_,
                                 false);
   }
 
   bool CompleteLoadFromURL(const GURL& url, const std::string& nonce,
                            bool was_from_cache) {
     return fetcher_->CompletePendingRequest(url, CreateDictionary(url, nonce),
                                             net_log_, was_from_cache);
   }
 
   std::string CreateDictionary(const GURL& url, const std::string& nonce) {
     std::string dict;
     dict.append("Domain: ");
     dict.append(url.host());
     dict.append("\n\n");
     dict.append(url.spec());
     dict.append(nonce);
     return dict;
   }
 
  protected:
   BoundNetLog net_log_;
-  scoped_ptr<SdchManager> manager_;
+  std::unique_ptr<SdchManager> manager_;
   MockSdchDictionaryFetcher* fetcher_;
-  scoped_ptr<SdchOwner> owner_;
+  std::unique_ptr<SdchOwner> owner_;
   TestURLRequestContext url_request_context_;
 };
 
 // Test an empty persistence store.
 TEST_F(SdchOwnerPersistenceTest, Empty) {
-  ResetOwner(make_scoped_ptr(new TestPrefStorage(true)));
+  ResetOwner(base::WrapUnique(new TestPrefStorage(true)));
   EXPECT_EQ(0, owner_->GetDictionaryCountForTesting());
 }
 
 // Test a persistence store with a bad version number.
 TEST_F(SdchOwnerPersistenceTest, Persistent_BadVersion) {
-  scoped_ptr<base::DictionaryValue> sdch_dict(new base::DictionaryValue());
+  std::unique_ptr<base::DictionaryValue> sdch_dict(new base::DictionaryValue());
   sdch_dict->SetInteger("version", 2);
 
-  scoped_ptr<TestPrefStorage> storage(new TestPrefStorage(true));
+  std::unique_ptr<TestPrefStorage> storage(new TestPrefStorage(true));
   storage->SetValue(std::move(sdch_dict));
 
   TestPrefStorage* old_storage = storage.get();  // Save storage pointer.
   ResetOwner(std::move(storage));  // Takes ownership of storage pointer.
 
   storage.reset(new TestPrefStorage(*old_storage));
   ResetOwner(std::move(storage));
   EXPECT_EQ(0, owner_->GetDictionaryCountForTesting());
 }
 
 // Test a persistence store with an empty dictionaries map.
 TEST_F(SdchOwnerPersistenceTest, Persistent_EmptyDictList) {
-  scoped_ptr<base::DictionaryValue> sdch_dict(new base::DictionaryValue());
-  scoped_ptr<base::DictionaryValue> dicts(new base::DictionaryValue());
+  std::unique_ptr<base::DictionaryValue> sdch_dict(new base::DictionaryValue());
+  std::unique_ptr<base::DictionaryValue> dicts(new base::DictionaryValue());
   sdch_dict->SetInteger("version", 1);
   sdch_dict->Set("dictionaries", std::move(dicts));
 
-  scoped_ptr<TestPrefStorage> storage(new TestPrefStorage(true));
+  std::unique_ptr<TestPrefStorage> storage(new TestPrefStorage(true));
   storage->SetValue(std::move(sdch_dict));
   ResetOwner(std::move(storage));
   EXPECT_EQ(0, owner_->GetDictionaryCountForTesting());
 }
 
 TEST_F(SdchOwnerPersistenceTest, OneDict) {
   const GURL url("http://www.example.com/dict");
 
-  scoped_ptr<TestPrefStorage> storage(new TestPrefStorage(true));
+  std::unique_ptr<TestPrefStorage> storage(new TestPrefStorage(true));
   TestPrefStorage* old_storage = storage.get();  // Save storage pointer.
   ResetOwner(std::move(storage));  // Takes ownership of storage pointer.
   EXPECT_EQ(0, owner_->GetDictionaryCountForTesting());
   InsertDictionaryForURL(url, "0");
   EXPECT_EQ(1, owner_->GetDictionaryCountForTesting());
 
   storage.reset(new TestPrefStorage(*old_storage));
   ResetOwner(std::move(storage));
   EXPECT_EQ(0, owner_->GetDictionaryCountForTesting());
   EXPECT_TRUE(CompleteLoadFromURL(url, "0", true));
   EXPECT_EQ(1, owner_->GetDictionaryCountForTesting());
 }
 
 TEST_F(SdchOwnerPersistenceTest, TwoDicts) {
   const GURL url0("http://www.example.com/dict0");
   const GURL url1("http://www.example.com/dict1");
 
-  scoped_ptr<TestPrefStorage> storage(new TestPrefStorage(true));
+  std::unique_ptr<TestPrefStorage> storage(new TestPrefStorage(true));
   TestPrefStorage* old_storage = storage.get();  // Save storage pointer.
   ResetOwner(std::move(storage));  // Takes ownership of storage pointer.
   InsertDictionaryForURL(url0, "0");
   InsertDictionaryForURL(url1, "1");
 
   storage.reset(new TestPrefStorage(*old_storage));
   ResetOwner(std::move(storage));
   EXPECT_TRUE(CompleteLoadFromURL(url0, "0", true));
   EXPECT_TRUE(CompleteLoadFromURL(url1, "1", true));
   EXPECT_EQ(2, owner_->GetDictionaryCountForTesting());
   EXPECT_TRUE(owner_->HasDictionaryFromURLForTesting(url0));
   EXPECT_TRUE(owner_->HasDictionaryFromURLForTesting(url1));
 }
 
 TEST_F(SdchOwnerPersistenceTest, OneGoodDictOneBadDict) {
   const GURL url0("http://www.example.com/dict0");
   const GURL url1("http://www.example.com/dict1");
 
-  scoped_ptr<TestPrefStorage> storage(new TestPrefStorage(true));
+  std::unique_ptr<TestPrefStorage> storage(new TestPrefStorage(true));
   TestPrefStorage* old_storage = storage.get();  // Save storage pointer.
   ResetOwner(std::move(storage));                // Takes ownership of storage.
   InsertDictionaryForURL(url0, "0");
   InsertDictionaryForURL(url1, "1");
 
   // Make a new storage based on the current contents of the old one.
   storage.reset(new TestPrefStorage(*old_storage));
   base::DictionaryValue* dict = nullptr;
   ASSERT_TRUE(GetDictionaryForURL(storage.get(), url1, nullptr, &dict));
   dict->Remove("use_count", nullptr);
 
   ResetOwner(std::move(storage));
   EXPECT_TRUE(CompleteLoadFromURL(url0, "0", true));
   EXPECT_FALSE(CompleteLoadFromURL(url1, "1", true));
   EXPECT_EQ(1, owner_->GetDictionaryCountForTesting());
   EXPECT_TRUE(owner_->HasDictionaryFromURLForTesting(url0));
   EXPECT_FALSE(owner_->HasDictionaryFromURLForTesting(url1));
 }
 
 TEST_F(SdchOwnerPersistenceTest, UsingDictionaryUpdatesUseCount) {
   const GURL url("http://www.example.com/dict");
 
-  scoped_ptr<TestPrefStorage> storage(new TestPrefStorage(true));
+  std::unique_ptr<TestPrefStorage> storage(new TestPrefStorage(true));
   TestPrefStorage* old_storage = storage.get();  // Save storage pointer.
   ResetOwner(std::move(storage));  // Takes ownership of storage pointer.
   InsertDictionaryForURL(url, "0");
 
   std::string hash;
   int old_count;
   storage.reset(new TestPrefStorage(*old_storage));
   {
     ClearOwner();
     base::DictionaryValue* dict = nullptr;
@@ skipping 13 matching lines @@
     ASSERT_TRUE(dict->GetInteger("use_count", &new_count));
   }
 
   EXPECT_EQ(old_count + 1, new_count);
 }
 
 TEST_F(SdchOwnerPersistenceTest, LoadingDictionaryMerges) {
   const GURL url0("http://www.example.com/dict0");
   const GURL url1("http://www.example.com/dict1");
 
-  scoped_ptr<TestPrefStorage> storage(new TestPrefStorage(true));
+  std::unique_ptr<TestPrefStorage> storage(new TestPrefStorage(true));
   TestPrefStorage* old_storage = storage.get();  // Save storage pointer.
   ResetOwner(std::move(storage));  // Takes ownership of storage pointer.
   InsertDictionaryForURL(url1, "1");
 
   storage.reset(new TestPrefStorage(*old_storage));
-  ResetOwner(scoped_ptr<SdchOwner::PrefStorage>());
+  ResetOwner(std::unique_ptr<SdchOwner::PrefStorage>());
   InsertDictionaryForURL(url0, "0");
   EXPECT_EQ(1, owner_->GetDictionaryCountForTesting());
   owner_->EnablePersistentStorage(std::move(storage));
   ASSERT_TRUE(CompleteLoadFromURL(url1, "1", true));
   EXPECT_EQ(2, owner_->GetDictionaryCountForTesting());
 }
 
 TEST_F(SdchOwnerPersistenceTest, PersistenceMetrics) {
   const GURL url0("http://www.example.com/dict0");
   const GURL url1("http://www.example.com/dict1");
 
-  scoped_ptr<TestPrefStorage> storage(new TestPrefStorage(true));
+  std::unique_ptr<TestPrefStorage> storage(new TestPrefStorage(true));
   TestPrefStorage* old_storage = storage.get();  // Save storage pointer.
   ResetOwner(std::move(storage));  // Takes ownership of storage pointer.
 
   InsertDictionaryForURL(url0, "0");
   InsertDictionaryForURL(url1, "1");
 
   storage.reset(new TestPrefStorage(*old_storage));
   ResetOwner(std::move(storage));
 
   base::HistogramTester tester;
 
   EXPECT_TRUE(CompleteLoadFromURL(url0, "0", true));
   EXPECT_TRUE(CompleteLoadFromURL(url1, "1", false));
 
   tester.ExpectTotalCount("Sdch3.NetworkBytesSpent", 1);
   tester.ExpectUniqueSample("Sdch3.NetworkBytesSpent",
                             CreateDictionary(url1, "1").size(), 1);
 }
 
 }  // namespace net