Convert //chrome/browser/metrics from scoped_ptr to std::unique_ptr

chrome/browser/metrics/thread_watcher_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 "chrome/browser/metrics/thread_watcher.h"
+
 #include <math.h>
 #include <stdint.h>
 
+#include <memory>
+
 #include "base/bind.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/macros.h"
-#include "base/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "base/single_thread_task_runner.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_split.h"
 #include "base/strings/string_tokenizer.h"
 #include "base/synchronization/condition_variable.h"
 #include "base/synchronization/lock.h"
 #include "base/synchronization/spin_wait.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/threading/platform_thread.h"
 #include "base/time/time.h"
 #include "build/build_config.h"
-#include "chrome/browser/metrics/thread_watcher.h"
 #include "chrome/common/chrome_switches.h"
 #include "content/public/test/test_browser_thread.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "testing/platform_test.h"
 
 using base::TimeDelta;
 using base::TimeTicks;
 using content::BrowserThread;
 
 enum State {
@@ skipping 276 matching lines @@
     db_thread_.reset();
     watchdog_thread_.reset();
     thread_watcher_list_ = nullptr;
   }
 
  private:
   base::MessageLoop message_loop_;
   base::Lock lock_;
   base::ConditionVariable setup_complete_;
   bool initialized_;
-  scoped_ptr<content::TestBrowserThread> db_thread_;
-  scoped_ptr<content::TestBrowserThread> io_thread_;
-  scoped_ptr<WatchDogThread> watchdog_thread_;
+  std::unique_ptr<content::TestBrowserThread> db_thread_;
+  std::unique_ptr<content::TestBrowserThread> io_thread_;
+  std::unique_ptr<WatchDogThread> watchdog_thread_;
 };
 
 // Define static constants.
 const TimeDelta ThreadWatcherTest::kSleepTime =
     TimeDelta::FromMilliseconds(50);
 const TimeDelta ThreadWatcherTest::kUnresponsiveTime =
     TimeDelta::FromMilliseconds(500);
 const BrowserThread::ID ThreadWatcherTest::io_thread_id = BrowserThread::IO;
 const std::string ThreadWatcherTest::io_thread_name = "IO";
 const BrowserThread::ID ThreadWatcherTest::db_thread_id = BrowserThread::DB;
@@ skipping 348 matching lines @@
   bool has_thread_watcher_list_;
   bool stopped_;
 };
 
 TEST_F(ThreadWatcherListTest, Restart) {
   ThreadWatcherList::g_initialize_delay_seconds = 1;
 
   base::MessageLoopForUI message_loop_for_ui;
   content::TestBrowserThread ui_thread(BrowserThread::UI, &message_loop_for_ui);
 
-  scoped_ptr<WatchDogThread> watchdog_thread_(new WatchDogThread());
+  std::unique_ptr<WatchDogThread> watchdog_thread_(new WatchDogThread());
   watchdog_thread_->StartAndWaitForTesting();
 
   // See http://crbug.com/347887.
   // StartWatchingAll() will PostDelayedTask to create g_thread_watcher_list_,
   // whilst StopWatchingAll() will just PostTask to destroy it.
   // Ensure that when Stop is called, Start will NOT create
   // g_thread_watcher_list_ later on.
   ThreadWatcherList::StartWatchingAll(*base::CommandLine::ForCurrentProcess());
   ThreadWatcherList::StopWatchingAll();
   message_loop_for_ui.task_runner()->PostDelayedTask(
@@ skipping 82 matching lines @@
 
   static void PostAndWaitForWatchdogThread(base::WaitableEvent* event) {
     WatchDogThread::PostDelayedTask(
         FROM_HERE,
         base::Bind(&JankTimeBombTest::OnJankTimeBombTask, event),
         base::TimeDelta::FromSeconds(0));
 
     event->Wait();
   }
 
-  scoped_ptr<WatchDogThread> watchdog_thread_;
+  std::unique_ptr<WatchDogThread> watchdog_thread_;
 
   DISALLOW_COPY_AND_ASSIGN(JankTimeBombTest);
 };
 
 // JankTimeBomb minimal constructor/destructor test..
 TEST_F(JankTimeBombTest, StartShutdownTest) {
   // Disarm's itself when it goes out of scope.
   TestingJankTimeBomb timebomb1(TimeDelta::FromMinutes(5));
   TestingJankTimeBomb timebomb2(TimeDelta::FromMinutes(5));
   WaitForWatchDogThreadPostTask();
   EXPECT_FALSE(timebomb1.alarm_invoked());
   EXPECT_FALSE(timebomb2.alarm_invoked());
 }
 
 TEST_F(JankTimeBombTest, ArmTest) {
   // Test firing of Alarm by passing empty delay.
   TestingJankTimeBomb timebomb((base::TimeDelta()));
   if (!timebomb.IsEnabled())
     return;
   WaitForWatchDogThreadPostTask();
   EXPECT_TRUE(timebomb.alarm_invoked());
 }