Convert //content from scoped_ptr to std::unique_ptr

content/public/test/test_launcher.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 "content/public/test/test_launcher.h"
 
 #include <stddef.h>
 
 #include <map>
+#include <memory>
 #include <set>
 #include <string>
 #include <vector>
 
 #include "base/bind_helpers.h"
 #include "base/command_line.h"
 #include "base/containers/hash_tables.h"
 #include "base/environment.h"
 #include "base/files/file_util.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/memory/linked_ptr.h"
-#include "base/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "base/stl_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/test/launcher/test_launcher.h"
 #include "base/test/test_suite.h"
 #include "base/test/test_switches.h"
 #include "base/test/test_timeouts.h"
 #include "base/time/time.h"
@@ skipping 114 matching lines @@
   // Launches test named |test_name| using parallel launcher,
   // given result of PRE_ test |pre_test_result|.
   void RunDependentTest(base::TestLauncher* test_launcher,
                         const std::string test_name,
                         const base::TestResult& pre_test_result);
 
   // Callback to receive result of a test.
   void GTestCallback(base::TestLauncher* test_launcher,
                      const std::vector<std::string>& test_names,
                      const std::string& test_name,
-                     scoped_ptr<TestState> test_state,
+                     std::unique_ptr<TestState> test_state,
                      int exit_code,
                      const base::TimeDelta& elapsed_time,
                      bool was_timeout,
                      const std::string& output);
 
   content::TestLauncherDelegate* launcher_delegate_;
 
   // Store dependent test name (map is indexed by full test name).
   typedef std::map<std::string, std::string> DependentTestMap;
   DependentTestMap dependent_test_map_;
@@ skipping 176 matching lines @@
   std::string test_name(test_names.front());
   std::vector<std::string> test_names_copy(
       test_names.begin() + 1, test_names.end());
 
   std::string test_name_no_pre(RemoveAnyPrePrefixes(test_name));
 
   base::CommandLine cmd_line(*base::CommandLine::ForCurrentProcess());
   base::TestLauncher::LaunchOptions test_launch_options;
   test_launch_options.flags = base::TestLauncher::USE_JOB_OBJECTS |
                               base::TestLauncher::ALLOW_BREAKAWAY_FROM_JOB;
-  scoped_ptr<TestState> test_state_ptr =
+  std::unique_ptr<TestState> test_state_ptr =
       launcher_delegate_->PreRunTest(&cmd_line, &test_launch_options);
   CHECK(launcher_delegate_->AdjustChildProcessCommandLine(
             &cmd_line, user_data_dir_map_[test_name_no_pre]));
 
   base::CommandLine new_cmd_line(cmd_line.GetProgram());
   base::CommandLine::SwitchMap switches = cmd_line.GetSwitches();
 
   // Strip out gtest_output flag because otherwise we would overwrite results
   // of the other tests.
   switches.erase(base::kGTestOutputFlag);
@@ skipping 42 matching lines @@
                        dependent_test_map_[test_name],
                        test_result);
     }
   }
 }
 
 void WrapperTestLauncherDelegate::GTestCallback(
     base::TestLauncher* test_launcher,
     const std::vector<std::string>& test_names,
     const std::string& test_name,
-    scoped_ptr<TestState> test_state,
+    std::unique_ptr<TestState> test_state,
     int exit_code,
     const base::TimeDelta& elapsed_time,
     bool was_timeout,
     const std::string& output) {
   base::TestResult result;
   result.full_name = test_name;
 
   // TODO(phajdan.jr): Recognize crashes.
   if (exit_code == 0)
     result.status = base::TestResult::TEST_SUCCESS;
@@ skipping 30 matching lines @@
 
 const char kHelpFlag[]   = "help";
 
 const char kLaunchAsBrowser[] = "as-browser";
 
 // See kManualTestPrefix above.
 const char kRunManualTestsFlag[] = "run-manual";
 
 const char kSingleProcessTestsFlag[]   = "single_process";
 
-scoped_ptr<TestState> TestLauncherDelegate::PreRunTest(
+std::unique_ptr<TestState> TestLauncherDelegate::PreRunTest(
     base::CommandLine* command_line,
     base::TestLauncher::LaunchOptions* test_launch_options) {
   return nullptr;
 }
 
 void TestLauncherDelegate::OnDoneRunningTests() {}
 
 TestLauncherDelegate::~TestLauncherDelegate() {
 }
 
 int LaunchTests(TestLauncherDelegate* launcher_delegate,
                 int default_jobs,
                 int argc,
                 char** argv) {
   DCHECK(!g_launcher_delegate);
   g_launcher_delegate = launcher_delegate;
 
   base::CommandLine::Init(argc, argv);
   const base::CommandLine* command_line =
       base::CommandLine::ForCurrentProcess();
 
   if (command_line->HasSwitch(kHelpFlag)) {
     PrintUsage();
     return 0;
   }
 
-  scoped_ptr<ContentMainDelegate> chrome_main_delegate(
+  std::unique_ptr<ContentMainDelegate> chrome_main_delegate(
       launcher_delegate->CreateContentMainDelegate());
   ContentMainParams params(chrome_main_delegate.get());
 
 #if defined(OS_WIN)
   sandbox::SandboxInterfaceInfo sandbox_info = {0};
   InitializeSandboxInfo(&sandbox_info);
 
   params.instance = GetModuleHandle(NULL);
   params.sandbox_info = &sandbox_info;
 #elif !defined(OS_ANDROID)
@@ skipping 43 matching lines @@
 
 TestLauncherDelegate* GetCurrentTestLauncherDelegate() {
   return g_launcher_delegate;
 }
 
 ContentMainParams* GetContentMainParams() {
   return g_params;
 }
 
 }  // namespace content