Convert //components/[f-n]* from scoped_ptr to std::unique_ptr

components/net_log/net_log_temp_file_unittest.cc

 // Copyright (c) 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 "components/net_log/net_log_temp_file.h"
 
 #include <stdint.h>
 
+#include <memory>
+
 #include "base/command_line.h"
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
 #include "base/files/scoped_file.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/json/json_reader.h"
-#include "base/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "base/values.h"
 #include "build/build_config.h"
 #include "components/net_log/chrome_net_log.h"
 #include "net/log/net_log_capture_mode.h"
 #include "net/log/write_to_file_net_log_observer.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace {
 
@@ skipping 42 matching lines @@
             base::FilePath(),
             net::NetLogCaptureMode::Default(),
             base::CommandLine::ForCurrentProcess()->GetCommandLineString(),
             kChannelString)),
         net_log_temp_file_(new TestNetLogTempFile(net_log_.get())) {
     EXPECT_TRUE(net_log_temp_file_->SetUpNetExportLogPath());
     net_export_log_ = net_log_temp_file_->log_path_;
   }
 
   std::string GetStateString() const {
-    scoped_ptr<base::DictionaryValue> dict(net_log_temp_file_->GetState());
+    std::unique_ptr<base::DictionaryValue> dict(net_log_temp_file_->GetState());
     std::string state;
     EXPECT_TRUE(dict->GetString("state", &state));
     return state;
   }
 
   std::string GetLogTypeString() const {
-    scoped_ptr<base::DictionaryValue> dict(net_log_temp_file_->GetState());
+    std::unique_ptr<base::DictionaryValue> dict(net_log_temp_file_->GetState());
     std::string log_type;
     EXPECT_TRUE(dict->GetString("logType", &log_type));
     return log_type;
   }
 
   // Make sure the export file has been created and is non-empty, as net
   // constants will always be written to it on creation.
   void VerifyNetExportLogExists() const {
     EXPECT_EQ(net_export_log_, net_log_temp_file_->log_path_);
     ASSERT_TRUE(base::PathExists(net_export_log_));
 
     int64_t file_size;
     // base::GetFileSize returns proper file size on open handles.
     ASSERT_TRUE(base::GetFileSize(net_export_log_, &file_size));
     EXPECT_GT(file_size, 0);
   }
 
   // Make sure the export file has been created and a valid JSON file.  This
   // should always be the case once logging has been stopped.
   void VerifyNetExportLogComplete() const {
     VerifyNetExportLogExists();
 
     std::string log;
     ASSERT_TRUE(ReadFileToString(net_export_log_, &log));
     base::JSONReader reader;
-    scoped_ptr<base::Value> json = base::JSONReader::Read(log);
+    std::unique_ptr<base::Value> json = base::JSONReader::Read(log);
     EXPECT_TRUE(json);
   }
 
   // Verify state and GetFilePath return correct values if EnsureInit() fails.
   void VerifyFilePathAndStateAfterEnsureInitFailure() {
     EXPECT_EQ("UNINITIALIZED", GetStateString());
     EXPECT_EQ(NetLogTempFile::STATE_UNINITIALIZED, net_log_temp_file_->state());
 
     base::FilePath net_export_file_path;
     EXPECT_FALSE(net_log_temp_file_->GetFilePath(&net_export_file_path));
@@ skipping 43 matching lines @@
   void VerifyFileAndStateAfterDoStopWithStripPrivateData() const {
     VerifyFileAndStateAfterDoStop(NetLogTempFile::LOG_TYPE_STRIP_PRIVATE_DATA,
                                   "STRIP_PRIVATE_DATA");
   }
 
   void VerifyFileAndStateAfterDoStopWithLogBytes() const {
     VerifyFileAndStateAfterDoStop(NetLogTempFile::LOG_TYPE_LOG_BYTES,
                                   "LOG_BYTES");
   }
 
-  scoped_ptr<ChromeNetLog> net_log_;
+  std::unique_ptr<ChromeNetLog> net_log_;
   // |net_log_temp_file_| is initialized after |net_log_| so that it can stop
   // obvserving on destruction.
-  scoped_ptr<TestNetLogTempFile> net_log_temp_file_;
+  std::unique_ptr<TestNetLogTempFile> net_log_temp_file_;
   base::FilePath net_export_log_;
 
  private:
   // Checks state after one of the DO_START* commands.
   void VerifyFileAndStateAfterStart(
       NetLogTempFile::LogType expected_log_type,
       const std::string& expected_log_type_string,
       net::NetLogCaptureMode expected_capture_mode) const {
     EXPECT_EQ(NetLogTempFile::STATE_LOGGING, net_log_temp_file_->state());
     EXPECT_EQ("LOGGING", GetStateString());
@@ skipping 195 matching lines @@
 
   net_log_temp_file_->ProcessCommand(NetLogTempFile::DO_STOP);
   VerifyFileAndStateAfterDoStop();
 
   int64_t new_stop_file_size;
   EXPECT_TRUE(base::GetFileSize(net_export_log_, &new_stop_file_size));
   EXPECT_GE(new_stop_file_size, stop_file_size);
 }
 
 }  // namespace net_log