Convert //content/browser from scoped_ptr to std::unique_ptr

content/browser/tracing/tracing_controller_browsertest.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 "content/public/browser/tracing_controller.h"
 
 #include <stdint.h>
 #include <utility>
 
 #include "base/files/file_util.h"
@@ skipping 41 matching lines @@
   }
   return false;
 }
 
 }  // namespace
 
 class TracingControllerTestEndpoint
     : public TracingController::TraceDataEndpoint {
  public:
   TracingControllerTestEndpoint(
-      base::Callback<void(scoped_ptr<const base::DictionaryValue>,
+      base::Callback<void(std::unique_ptr<const base::DictionaryValue>,
                           base::RefCountedString*)> done_callback)
       : done_callback_(done_callback) {}
 
   void ReceiveTraceChunk(const std::string& chunk) override {
     EXPECT_FALSE(chunk.empty());
     trace_ += chunk;
   }
 
   void ReceiveTraceFinalContents(
-      scoped_ptr<const base::DictionaryValue> metadata,
+      std::unique_ptr<const base::DictionaryValue> metadata,
       const std::string& contents) override {
     EXPECT_EQ(trace_, contents);
 
     std::string tmp = contents;
     scoped_refptr<base::RefCountedString> chunk_ptr =
         base::RefCountedString::TakeString(&tmp);
 
     BrowserThread::PostTask(
         BrowserThread::UI, FROM_HERE,
         base::Bind(done_callback_, base::Passed(std::move(metadata)),
                    base::RetainedRef(chunk_ptr)));
   }
 
  protected:
   ~TracingControllerTestEndpoint() override {}
 
   std::string trace_;
-  base::Callback<void(scoped_ptr<const base::DictionaryValue>,
-                      base::RefCountedString*)> done_callback_;
+  base::Callback<void(std::unique_ptr<const base::DictionaryValue>,
+                      base::RefCountedString*)>
+      done_callback_;
 };
 
 class TracingControllerTest : public ContentBrowserTest {
  public:
   TracingControllerTest() {}
 
   void SetUp() override {
     get_categories_done_callback_count_ = 0;
     enable_recording_done_callback_count_ = 0;
     disable_recording_done_callback_count_ = 0;
@@ skipping 13 matching lines @@
     quit_callback.Run();
   }
 
   void StartTracingDoneCallbackTest(base::Closure quit_callback) {
     enable_recording_done_callback_count_++;
     quit_callback.Run();
   }
 
   void StopTracingStringDoneCallbackTest(
       base::Closure quit_callback,
-      scoped_ptr<const base::DictionaryValue> metadata,
+      std::unique_ptr<const base::DictionaryValue> metadata,
       base::RefCountedString* data) {
     disable_recording_done_callback_count_++;
     last_metadata_.reset(metadata.release());
     last_data_ = data->data();
     EXPECT_TRUE(data->size() > 0);
     quit_callback.Run();
   }
 
   void StopTracingFileDoneCallbackTest(base::Closure quit_callback,
                                             const base::FilePath& file_path) {
@@ skipping 43 matching lines @@
                      run_loop.QuitClosure());
       bool result = controller->StartTracing(
           TraceConfig(), callback);
       ASSERT_TRUE(result);
       run_loop.Run();
       EXPECT_EQ(enable_recording_done_callback_count(), 1);
     }
 
     {
       base::RunLoop run_loop;
-      base::Callback<void(scoped_ptr<const base::DictionaryValue>,
-                          base::RefCountedString*)> callback = base::Bind(
-          &TracingControllerTest::StopTracingStringDoneCallbackTest,
-          base::Unretained(this),
-          run_loop.QuitClosure());
+      base::Callback<void(std::unique_ptr<const base::DictionaryValue>,
+                          base::RefCountedString*)>
+          callback = base::Bind(
+              &TracingControllerTest::StopTracingStringDoneCallbackTest,
+              base::Unretained(this), run_loop.QuitClosure());
       bool result = controller->StopTracing(
           TracingController::CreateStringSink(callback));
       ASSERT_TRUE(result);
       run_loop.Run();
       EXPECT_EQ(disable_recording_done_callback_count(), 1);
     }
   }
 
   void TestStartAndStopTracingStringWithFilter() {
     Navigate(shell());
@@ skipping 13 matching lines @@
       config.EnableArgumentFilter();
 
       bool result = controller->StartTracing(config, callback);
       ASSERT_TRUE(result);
       run_loop.Run();
       EXPECT_EQ(enable_recording_done_callback_count(), 1);
     }
 
     {
       base::RunLoop run_loop;
-      base::Callback<void(scoped_ptr<const base::DictionaryValue>,
-                          base::RefCountedString*)> callback = base::Bind(
-          &TracingControllerTest::StopTracingStringDoneCallbackTest,
-          base::Unretained(this),
-          run_loop.QuitClosure());
+      base::Callback<void(std::unique_ptr<const base::DictionaryValue>,
+                          base::RefCountedString*)>
+          callback = base::Bind(
+              &TracingControllerTest::StopTracingStringDoneCallbackTest,
+              base::Unretained(this), run_loop.QuitClosure());
 
       scoped_refptr<TracingController::TraceDataSink> trace_data_sink =
           TracingController::CreateStringSink(callback);
 
       trace_data_sink->SetMetadataFilterPredicate(
           base::Bind(&IsMetadataWhitelisted));
       base::DictionaryValue metadata;
       metadata.SetString("not-whitelisted", "this_not_found");
       trace_data_sink->AddMetadata(metadata);
 
@@ skipping 15 matching lines @@
           base::Bind(&TracingControllerTest::StartTracingDoneCallbackTest,
                      base::Unretained(this), run_loop.QuitClosure());
       bool result = controller->StartTracing(TraceConfig(), callback);
       ASSERT_TRUE(result);
       run_loop.Run();
       EXPECT_EQ(enable_recording_done_callback_count(), 1);
     }
 
     {
       base::RunLoop run_loop;
-      base::Callback<void(scoped_ptr<const base::DictionaryValue>,
-                          base::RefCountedString*)> callback = base::Bind(
-          &TracingControllerTest::StopTracingStringDoneCallbackTest,
-          base::Unretained(this), run_loop.QuitClosure());
+      base::Callback<void(std::unique_ptr<const base::DictionaryValue>,
+                          base::RefCountedString*)>
+          callback = base::Bind(
+              &TracingControllerTest::StopTracingStringDoneCallbackTest,
+              base::Unretained(this), run_loop.QuitClosure());
       bool result = controller->StopTracing(
           TracingController::CreateCompressedStringSink(
               new TracingControllerTestEndpoint(callback)));
       ASSERT_TRUE(result);
       run_loop.Run();
       EXPECT_EQ(disable_recording_done_callback_count(), 1);
     }
   }
 
   void TestStartAndStopTracingCompressedFile(
@@ skipping 59 matching lines @@
       run_loop.Run();
       EXPECT_EQ(disable_recording_done_callback_count(), 1);
     }
   }
 
  private:
   int get_categories_done_callback_count_;
   int enable_recording_done_callback_count_;
   int disable_recording_done_callback_count_;
   base::FilePath last_actual_recording_file_path_;
-  scoped_ptr<const base::DictionaryValue> last_metadata_;
+  std::unique_ptr<const base::DictionaryValue> last_metadata_;
   std::string last_data_;
 };
 
 IN_PROC_BROWSER_TEST_F(TracingControllerTest, GetCategories) {
   Navigate(shell());
 
   TracingController* controller = TracingController::GetInstance();
 
   base::RunLoop run_loop;
   TracingController::GetCategoriesDoneCallback callback =
@@ skipping 93 matching lines @@
 
   TracingController* controller = TracingController::GetInstance();
   EXPECT_TRUE(controller->StartTracing(
       TraceConfig(),
       TracingController::StartTracingDoneCallback()));
   EXPECT_TRUE(controller->StopTracing(NULL));
   base::RunLoop().RunUntilIdle();
 }
 
 }  // namespace content