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

net/tools/disk_cache_memory_test/disk_cache_memory_test.cc

 // Copyright 2013 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 <cstdlib>
 #include <fstream>
 #include <iostream>
+#include <memory>
 #include <string>
 #include <vector>
 
 #include "base/at_exit.h"
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/command_line.h"
 #include "base/files/file_path.h"
 #include "base/logging.h"
-#include "base/memory/scoped_ptr.h"
 #include "base/run_loop.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_piece.h"
 #include "base/strings/string_split.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/thread_task_runner_handle.h"
 #include "net/base/cache_type.h"
 #include "net/base/net_errors.h"
 #include "net/disk_cache/disk_cache.h"
 #include "net/disk_cache/simple/simple_backend_impl.h"
 #include "net/disk_cache/simple/simple_index.h"
 
 namespace disk_cache {
 namespace {
 
 const char kBlockFileBackendType[] = "block_file";
 const char kSimpleBackendType[] = "simple";
 
 const char kDiskCacheType[] = "disk_cache";
 const char kAppCacheType[] = "app_cache";
 
 const char kPrivateDirty[] = "Private_Dirty:";
 const char kReadWrite[] = "rw-";
 const char kHeap[] = "[heap]";
 const char kKb[] = "kB";
 
 struct CacheSpec {
  public:
-  static scoped_ptr<CacheSpec> Parse(const std::string& spec_string) {
+  static std::unique_ptr<CacheSpec> Parse(const std::string& spec_string) {
     std::vector<std::string> tokens = base::SplitString(
         spec_string, ":", base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
     if (tokens.size() != 3)
-      return scoped_ptr<CacheSpec>();
+      return std::unique_ptr<CacheSpec>();
     if (tokens[0] != kBlockFileBackendType && tokens[0] != kSimpleBackendType)
-      return scoped_ptr<CacheSpec>();
+      return std::unique_ptr<CacheSpec>();
     if (tokens[1] != kDiskCacheType && tokens[1] != kAppCacheType)
-      return scoped_ptr<CacheSpec>();
-    return scoped_ptr<CacheSpec>(new CacheSpec(
+      return std::unique_ptr<CacheSpec>();
+    return std::unique_ptr<CacheSpec>(new CacheSpec(
         tokens[0] == kBlockFileBackendType ? net::CACHE_BACKEND_BLOCKFILE
                                            : net::CACHE_BACKEND_SIMPLE,
         tokens[1] == kDiskCacheType ? net::DISK_CACHE : net::APP_CACHE,
         base::FilePath(tokens[2])));
   }
 
   const net::BackendType backend_type;
   const net::CacheType cache_type;
   const base::FilePath path;
 
@@ skipping 11 matching lines @@
                                 bool* succeeded,
                                 int net_error) {
   if (net_error == net::OK) {
     *succeeded = true;
   } else {
     *succeeded = false;
   }
   run_loop->Quit();
 }
 
-scoped_ptr<Backend> CreateAndInitBackend(const CacheSpec& spec) {
-  scoped_ptr<Backend> result;
-  scoped_ptr<Backend> backend;
+std::unique_ptr<Backend> CreateAndInitBackend(const CacheSpec& spec) {
+  std::unique_ptr<Backend> result;
+  std::unique_ptr<Backend> backend;
   bool succeeded = false;
   base::RunLoop run_loop;
   const net::CompletionCallback callback = base::Bind(
       &SetSuccessCodeOnCompletion,
       base::Unretained(&run_loop),
       base::Unretained(&succeeded));
   const int net_error = CreateCacheBackend(
       spec.cache_type, spec.backend_type, spec.path, 0, false,
       base::ThreadTaskRunnerHandle::Get(), NULL, &backend, callback);
   if (net_error == net::OK)
@@ skipping 115 matching lines @@
         total_size += size;
         is_private_dirty = false;
       }
       if (!std::getline(maps_file, line) || line.empty())
         return total_size;
     }
   }
   return total_size;
 }
 
-bool CacheMemTest(const std::vector<scoped_ptr<CacheSpec>>& specs) {
-  std::vector<scoped_ptr<Backend>> backends;
+bool CacheMemTest(const std::vector<std::unique_ptr<CacheSpec>>& specs) {
+  std::vector<std::unique_ptr<Backend>> backends;
   for (const auto& it : specs) {
-    scoped_ptr<Backend> backend = CreateAndInitBackend(*it);
+    std::unique_ptr<Backend> backend = CreateAndInitBackend(*it);
     if (!backend)
       return false;
     std::cout << "Number of entries in " << it->path.LossyDisplayName() << " : "
               << backend->GetEntryCount() << std::endl;
     backends.push_back(std::move(backend));
   }
   const uint64_t memory_consumption = GetMemoryConsumption();
   std::cout << "Private dirty memory: " << memory_consumption << " kB"
             << std::endl;
   return true;
 }
 
 void PrintUsage(std::ostream* stream) {
   *stream << "Usage: disk_cache_mem_test "
           << "--spec-1=<spec> "
           << "[--spec-2=<spec>]"
           << std::endl
           << "  with <cache_spec>=<backend_type>:<cache_type>:<cache_path>"
           << std::endl
           << "       <backend_type>='block_file'|'simple'" << std::endl
           << "       <cache_type>='disk_cache'|'app_cache'" << std::endl
           << "       <cache_path>=file system path" << std::endl;
 }
 
 bool ParseAndStoreSpec(const std::string& spec_str,
-                       std::vector<scoped_ptr<CacheSpec>>* specs) {
-  scoped_ptr<CacheSpec> spec = CacheSpec::Parse(spec_str);
+                       std::vector<std::unique_ptr<CacheSpec>>* specs) {
+  std::unique_ptr<CacheSpec> spec = CacheSpec::Parse(spec_str);
   if (!spec) {
     PrintUsage(&std::cerr);
     return false;
   }
   specs->push_back(std::move(spec));
   return true;
 }
 
 bool Main(int argc, char** argv) {
   base::AtExitManager at_exit_manager;
   base::MessageLoopForIO message_loop;
   base::CommandLine::Init(argc, argv);
   const base::CommandLine& command_line =
       *base::CommandLine::ForCurrentProcess();
   if (command_line.HasSwitch("help")) {
     PrintUsage(&std::cout);
     return true;
   }
   if ((command_line.GetSwitches().size() != 1 &&
        command_line.GetSwitches().size() != 2) ||
       !command_line.HasSwitch("spec-1") ||
       (command_line.GetSwitches().size() == 2 &&
        !command_line.HasSwitch("spec-2"))) {
     PrintUsage(&std::cerr);
     return false;
   }
-  std::vector<scoped_ptr<CacheSpec>> specs;
+  std::vector<std::unique_ptr<CacheSpec>> specs;
   const std::string spec_str_1 = command_line.GetSwitchValueASCII("spec-1");
   if (!ParseAndStoreSpec(spec_str_1, &specs))
     return false;
   if (command_line.HasSwitch("spec-2")) {
     const std::string spec_str_2 = command_line.GetSwitchValueASCII("spec-2");
     if (!ParseAndStoreSpec(spec_str_2, &specs))
       return false;
   }
   return CacheMemTest(specs);
 }
 
 }  // namespace
 }  // namespace disk_cache
 
 int main(int argc, char** argv) {
   return !disk_cache::Main(argc, argv);
 }