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

chrome/browser/ui/webui/sync_internals_message_handler_unittest.cc

 // Copyright 2015 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/ui/webui/sync_internals_message_handler.h"
 
+#include <memory>
 #include <utility>
 
 #include "base/command_line.h"
 #include "base/memory/ref_counted.h"
-#include "base/memory/scoped_ptr.h"
 #include "chrome/test/base/testing_profile.h"
 #include "components/browser_sync/common/browser_sync_switches.h"
 #include "components/sync_driver/about_sync_util.h"
 #include "components/sync_driver/sync_service.h"
 #include "content/public/browser/site_instance.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/test/test_browser_thread_bundle.h"
 #include "content/public/test/test_web_ui.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace {
 
 class TestableSyncInternalsMessageHandler : public SyncInternalsMessageHandler {
  public:
   explicit TestableSyncInternalsMessageHandler(
       content::WebUI* web_ui,
-      scoped_ptr<AboutSyncDataExtractor> about_sync_data_extractor)
+      std::unique_ptr<AboutSyncDataExtractor> about_sync_data_extractor)
       : SyncInternalsMessageHandler(std::move(about_sync_data_extractor)) {
     set_web_ui(web_ui);
   }
 };
 
 class FakeExtractor : public AboutSyncDataExtractor {
  public:
-  scoped_ptr<base::DictionaryValue> ConstructAboutInformation(
+  std::unique_ptr<base::DictionaryValue> ConstructAboutInformation(
       sync_driver::SyncService* service,
       SigninManagerBase* signin) override {
     call_count_++;
     last_service_ = service;
     last_signin_ = signin;
-    scoped_ptr<base::DictionaryValue> dictionary(new base::DictionaryValue());
+    std::unique_ptr<base::DictionaryValue> dictionary(
+        new base::DictionaryValue());
     dictionary->SetString("fake_key", "fake_value");
     return dictionary;
   }
 
   int call_count() const { return call_count_; }
   sync_driver::SyncService* last_service() const { return last_service_; }
   SigninManagerBase* last_signin() const { return last_signin_; }
 
  private:
   int call_count_ = 0;
   sync_driver::SyncService* last_service_ = nullptr;
   SigninManagerBase* last_signin_ = nullptr;
 };
 
 class SyncInternalsMessageHandlerTest : public ::testing::Test {
  protected:
   SyncInternalsMessageHandlerTest() {
     site_instance_ = content::SiteInstance::Create(&profile_);
     web_contents_.reset(content::WebContents::Create(
         content::WebContents::CreateParams(&profile_, site_instance_.get())));
     web_ui_.set_web_contents(web_contents_.get());
     fake_extractor_ = new FakeExtractor();
     handler_.reset(new TestableSyncInternalsMessageHandler(
-        &web_ui_, scoped_ptr<FakeExtractor>(fake_extractor_)));
+        &web_ui_, std::unique_ptr<FakeExtractor>(fake_extractor_)));
   }
 
   void ValidateAboutInfoCall() {
     const ScopedVector<content::TestWebUI::CallData>& data_vector =
         web_ui_.call_data();
     ASSERT_FALSE(data_vector.empty());
     EXPECT_EQ(1u, data_vector.size());
 
     const content::TestWebUI::CallData& call_data = *data_vector[0];
 
@@ skipping 18 matching lines @@
   }
 
   SyncInternalsMessageHandler* handler() { return handler_.get(); }
   FakeExtractor* fake_extractor() { return fake_extractor_; }
 
  private:
   content::TestBrowserThreadBundle thread_bundle_;
   TestingProfile profile_;
   content::TestWebUI web_ui_;
   scoped_refptr<content::SiteInstance> site_instance_;
-  scoped_ptr<content::WebContents> web_contents_;
-  scoped_ptr<SyncInternalsMessageHandler> handler_;
+  std::unique_ptr<content::WebContents> web_contents_;
+  std::unique_ptr<SyncInternalsMessageHandler> handler_;
 
   // Non-owning pointer to the about information the handler uses. This
   // extractor is owned by the handler.
   FakeExtractor* fake_extractor_;
 };
 
 }  // namespace
 
 TEST_F(SyncInternalsMessageHandlerTest, SendAboutInfoWithService) {
   handler()->OnStateChanged();
   EXPECT_EQ(1, fake_extractor()->call_count());
   EXPECT_NE(nullptr, fake_extractor()->last_service());
   EXPECT_NE(nullptr, fake_extractor()->last_signin());
   ValidateAboutInfoCall();
 }
 
 TEST_F(SyncInternalsMessageHandlerTest, SendAboutInfoWithoutService) {
   base::CommandLine::ForCurrentProcess()->AppendSwitch(switches::kDisableSync);
   handler()->OnStateChanged();
   EXPECT_EQ(1, fake_extractor()->call_count());
   EXPECT_EQ(nullptr, fake_extractor()->last_service());
   EXPECT_EQ(nullptr, fake_extractor()->last_signin());
   ValidateAboutInfoCall();
 }