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

net/disk_cache/entry_unittest.cc

 // Copyright (c) 2012 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 <utility>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/files/file.h"
 #include "base/files/file_util.h"
@@ skipping 1607 matching lines @@
                 0, buf.get(), kSize, net::CompletionCallback()));
 
   // This write creates a child entry and writes to it.
   EXPECT_EQ(kSize,
             parent_entry->WriteSparseData(
                 8192, buf.get(), kSize, net::CompletionCallback()));
 
   parent_entry->Close();
 
   // Perform the enumerations.
-  scoped_ptr<TestIterator> iter = CreateIterator();
+  std::unique_ptr<TestIterator> iter = CreateIterator();
   disk_cache::Entry* entry = NULL;
   int count = 0;
   while (iter->OpenNextEntry(&entry) == net::OK) {
     ASSERT_TRUE(entry != NULL);
     ++count;
     disk_cache::MemEntryImpl* mem_entry =
         reinterpret_cast<disk_cache::MemEntryImpl*>(entry);
     EXPECT_EQ(disk_cache::MemEntryImpl::PARENT_ENTRY, mem_entry->type());
     mem_entry->Close();
   }
@@ skipping 539 matching lines @@
   InitCache();
   DoomSparseEntry();
 }
 
 // A CompletionCallback wrapper that deletes the cache from within the callback.
 // The way a CompletionCallback works means that all tasks (even new ones)
 // are executed by the message loop before returning to the caller so the only
 // way to simulate a race is to execute what we want on the callback.
 class SparseTestCompletionCallback: public net::TestCompletionCallback {
  public:
-  explicit SparseTestCompletionCallback(scoped_ptr<disk_cache::Backend> cache)
+  explicit SparseTestCompletionCallback(
+      std::unique_ptr<disk_cache::Backend> cache)
       : cache_(std::move(cache)) {}
 
  private:
   void SetResult(int result) override {
     cache_.reset();
     TestCompletionCallback::SetResult(result);
   }
 
-  scoped_ptr<disk_cache::Backend> cache_;
+  std::unique_ptr<disk_cache::Backend> cache_;
   DISALLOW_COPY_AND_ASSIGN(SparseTestCompletionCallback);
 };
 
 // Tests that we don't crash when the backend is deleted while we are working
 // deleting the sub-entries of a sparse entry.
 TEST_F(DiskCacheEntryTest, DoomSparseEntry2) {
   UseCurrentThread();
   InitCache();
   std::string key("the key");
   disk_cache::Entry* entry;
@@ skipping 136 matching lines @@
   scoped_refptr<net::IOBuffer> buf1(new net::IOBuffer(kSize));
   CacheTestFillBuffer(buf1->data(), kSize, false);
 
   const int k1Meg = 1024 * 1024;
   EXPECT_EQ(kSize, WriteSparseData(entry, 8192, buf1.get(), kSize));
   EXPECT_EQ(kSize, WriteSparseData(entry, k1Meg + 8192, buf1.get(), kSize));
   EXPECT_EQ(kSize, WriteSparseData(entry, 2 * k1Meg + 8192, buf1.get(), kSize));
   entry->Close();
   EXPECT_EQ(4, cache_->GetEntryCount());
 
-  scoped_ptr<TestIterator> iter = CreateIterator();
+  std::unique_ptr<TestIterator> iter = CreateIterator();
   int count = 0;
   std::string child_key[2];
   while (iter->OpenNextEntry(&entry) == net::OK) {
     ASSERT_TRUE(entry != NULL);
     // Writing to an entry will alter the LRU list and invalidate the iterator.
     if (entry->GetKey() != key && count < 2)
       child_key[count++] = entry->GetKey();
     entry->Close();
   }
   for (int i = 0; i < 2; i++) {
@@ skipping 1792 matching lines @@
   ASSERT_EQ(net::OK, OpenEntry(key, &entry));
 
   ret = entry->ReadSparseData(0, buffer.get(), kSize, callback.callback());
   EXPECT_EQ(0, callback.GetResult(ret));
 
   ret = entry->ReadSparseData(kSize, buffer.get(), kSize, callback.callback());
   EXPECT_EQ(kSize, callback.GetResult(ret));
 
   entry->Close();
 }