Replace scoped_ptr with std::unique_ptr in //ui

ui/views/corewm/tooltip_controller_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 "ui/views/corewm/tooltip_controller.h"
 
 #include "base/macros.h"
 #include "base/strings/utf_string_conversions.h"
 #include "build/build_config.h"
 #include "ui/aura/client/cursor_client.h"
@@ skipping 71 matching lines @@
   void SetUp() override {
 #if defined(OS_CHROMEOS)
     views_delegate_.reset(new TestViewsDelegate);
 #else
     views_delegate_.reset(new DesktopTestViewsDelegate);
 #endif
 
     aura::test::AuraTestBase::SetUp();
     new wm::DefaultActivationClient(root_window());
 #if defined(OS_CHROMEOS)
-    controller_.reset(new TooltipController(
-          scoped_ptr<views::corewm::Tooltip>(
-              new views::corewm::TooltipAura)));
+    controller_.reset(
+        new TooltipController(std::unique_ptr<views::corewm::Tooltip>(
+            new views::corewm::TooltipAura)));
     root_window()->AddPreTargetHandler(controller_.get());
     SetTooltipClient(root_window(), controller_.get());
 #endif
     widget_.reset(CreateWidget(root_window()));
     widget_->SetContentsView(new View);
     view_ = new TooltipTestView;
     widget_->GetContentsView()->AddChildView(view_);
     view_->SetBoundsRect(widget_->GetContentsView()->GetLocalBounds());
     helper_.reset(new TooltipControllerTestHelper(
                       GetController(widget_.get())));
@@ skipping 23 matching lines @@
   }
 
   TooltipTestView* PrepareSecondView() {
     TooltipTestView* view2 = new TooltipTestView;
     widget_->GetContentsView()->AddChildView(view2);
     view_->SetBounds(0, 0, 100, 100);
     view2->SetBounds(100, 0, 100, 100);
     return view2;
   }
 
-  scoped_ptr<views::Widget> widget_;
+  std::unique_ptr<views::Widget> widget_;
   TooltipTestView* view_;
-  scoped_ptr<TooltipControllerTestHelper> helper_;
-  scoped_ptr<ui::test::EventGenerator> generator_;
+  std::unique_ptr<TooltipControllerTestHelper> helper_;
+  std::unique_ptr<ui::test::EventGenerator> generator_;
 
  private:
-  scoped_ptr<TooltipController> controller_;
+  std::unique_ptr<TooltipController> controller_;
 
-  scoped_ptr<views::TestViewsDelegate> views_delegate_;
+  std::unique_ptr<views::TestViewsDelegate> views_delegate_;
 
 #if defined(OS_WIN)
   ui::ScopedOleInitializer ole_initializer_;
 #endif
 
   DISALLOW_COPY_AND_ASSIGN(TooltipControllerTest);
 };
 
 TEST_F(TooltipControllerTest, ViewTooltip) {
   view_->set_tooltip_text(ASCIIToUTF16("Tooltip Text"));
@@ skipping 277 matching lines @@
 #if !defined(OS_CHROMEOS)
     gfx::Screen::SetScreenInstance(test_screen());
     desktop_screen_.reset();
 #endif
     aura::client::SetScreenPositionClient(GetRootWindow(), NULL);
     TooltipControllerTest::TearDown();
   }
 
  private:
   wm::DefaultScreenPositionClient screen_position_client_;
-  scoped_ptr<gfx::Screen> desktop_screen_;
+  std::unique_ptr<gfx::Screen> desktop_screen_;
 
   DISALLOW_COPY_AND_ASSIGN(TooltipControllerCaptureTest);
 };
 
 // Verifies when capture is released the TooltipController resets state.
 // Flaky on all builders.  http://crbug.com/388268
 TEST_F(TooltipControllerCaptureTest, DISABLED_CloseOnCaptureLost) {
   view_->GetWidget()->SetCapture(view_);
   RunAllPendingInMessageLoop();
   view_->set_tooltip_text(ASCIIToUTF16("Tooltip Text"));
@@ skipping 20 matching lines @@
 #define MAYBE_Capture Capture
 #endif
 // Verifies the correct window is found for tooltips when there is a capture.
 TEST_F(TooltipControllerCaptureTest, MAYBE_Capture) {
   const base::string16 tooltip_text(ASCIIToUTF16("1"));
   const base::string16 tooltip_text2(ASCIIToUTF16("2"));
 
   widget_->SetBounds(gfx::Rect(0, 0, 200, 200));
   view_->set_tooltip_text(tooltip_text);
 
-  scoped_ptr<views::Widget> widget2(CreateWidget(root_window()));
+  std::unique_ptr<views::Widget> widget2(CreateWidget(root_window()));
   widget2->SetContentsView(new View);
   TooltipTestView* view2 = new TooltipTestView;
   widget2->GetContentsView()->AddChildView(view2);
   view2->set_tooltip_text(tooltip_text2);
   widget2->SetBounds(gfx::Rect(0, 0, 200, 200));
   view2->SetBoundsRect(widget2->GetContentsView()->GetLocalBounds());
 
   widget_->SetCapture(view_);
   EXPECT_TRUE(widget_->HasCapture());
   widget2->Show();
@@ skipping 63 matching lines @@
 // Use for tests that don't depend upon views.
 class TooltipControllerTest2 : public aura::test::AuraTestBase {
  public:
   TooltipControllerTest2() : test_tooltip_(new TestTooltip) {}
   ~TooltipControllerTest2() override {}
 
   void SetUp() override {
     wm_state_.reset(new wm::WMState);
     aura::test::AuraTestBase::SetUp();
     new wm::DefaultActivationClient(root_window());
-    controller_.reset(new TooltipController(
-                          scoped_ptr<corewm::Tooltip>(test_tooltip_)));
+    controller_.reset(
+        new TooltipController(std::unique_ptr<corewm::Tooltip>(test_tooltip_)));
     root_window()->AddPreTargetHandler(controller_.get());
     SetTooltipClient(root_window(), controller_.get());
     helper_.reset(new TooltipControllerTestHelper(controller_.get()));
     generator_.reset(new ui::test::EventGenerator(root_window()));
   }
 
   void TearDown() override {
     root_window()->RemovePreTargetHandler(controller_.get());
     aura::client::SetTooltipClient(root_window(), NULL);
     controller_.reset();
     generator_.reset();
     helper_.reset();
     aura::test::AuraTestBase::TearDown();
     wm_state_.reset();
   }
 
  protected:
   // Owned by |controller_|.
   TestTooltip* test_tooltip_;
-  scoped_ptr<TooltipControllerTestHelper> helper_;
-  scoped_ptr<ui::test::EventGenerator> generator_;
+  std::unique_ptr<TooltipControllerTestHelper> helper_;
+  std::unique_ptr<ui::test::EventGenerator> generator_;
 
  private:
-  scoped_ptr<TooltipController> controller_;
-  scoped_ptr<wm::WMState> wm_state_;
+  std::unique_ptr<TooltipController> controller_;
+  std::unique_ptr<wm::WMState> wm_state_;
 
   DISALLOW_COPY_AND_ASSIGN(TooltipControllerTest2);
 };
 
 TEST_F(TooltipControllerTest2, VerifyLeadingTrailingWhitespaceStripped) {
   aura::test::TestWindowDelegate test_delegate;
-  scoped_ptr<aura::Window> window(
+  std::unique_ptr<aura::Window> window(
       CreateNormalWindow(100, root_window(), &test_delegate));
   window->SetBounds(gfx::Rect(0, 0, 300, 300));
   base::string16 tooltip_text(ASCIIToUTF16(" \nx  "));
   aura::client::SetTooltipText(window.get(), &tooltip_text);
   generator_->MoveMouseToCenterOf(window.get());
   helper_->FireTooltipTimer();
   EXPECT_EQ(ASCIIToUTF16("x"), test_tooltip_->tooltip_text());
 }
 
 // Verifies that tooltip is hidden and tooltip window closed upon cancel mode.
 TEST_F(TooltipControllerTest2, CloseOnCancelMode) {
   aura::test::TestWindowDelegate test_delegate;
-  scoped_ptr<aura::Window> window(
+  std::unique_ptr<aura::Window> window(
       CreateNormalWindow(100, root_window(), &test_delegate));
   window->SetBounds(gfx::Rect(0, 0, 300, 300));
   base::string16 tooltip_text(ASCIIToUTF16("Tooltip Text"));
   aura::client::SetTooltipText(window.get(), &tooltip_text);
   generator_->MoveMouseToCenterOf(window.get());
 
   // Fire tooltip timer so tooltip becomes visible.
   helper_->FireTooltipTimer();
   EXPECT_TRUE(helper_->IsTooltipVisible());
 
@@ skipping 17 matching lines @@
     new wm::DefaultActivationClient(root_window());
 
     widget_.reset(CreateWidget(root_window()));
     widget_->SetContentsView(new View);
     view_ = new TooltipTestView;
     widget_->GetContentsView()->AddChildView(view_);
     view_->SetBoundsRect(widget_->GetContentsView()->GetLocalBounds());
 
     generator_.reset(new ui::test::EventGenerator(GetRootWindow()));
     controller_.reset(new TooltipController(
-        scoped_ptr<views::corewm::Tooltip>(test_tooltip_)));
+        std::unique_ptr<views::corewm::Tooltip>(test_tooltip_)));
     GetRootWindow()->RemovePreTargetHandler(
         static_cast<TooltipController*>(aura::client::GetTooltipClient(
             widget_->GetNativeWindow()->GetRootWindow())));
     GetRootWindow()->AddPreTargetHandler(controller_.get());
     helper_.reset(new TooltipControllerTestHelper(controller_.get()));
     SetTooltipClient(GetRootWindow(), controller_.get());
   }
 
   void TearDown() override {
     GetRootWindow()->RemovePreTargetHandler(controller_.get());
     aura::client::SetTooltipClient(GetRootWindow(), NULL);
 
     controller_.reset();
     generator_.reset();
     helper_.reset();
     widget_.reset();
     aura::test::AuraTestBase::TearDown();
     wm_state_.reset();
   }
 
   aura::Window* GetWindow() { return widget_->GetNativeWindow(); }
 
  protected:
   // Owned by |controller_|.
   TestTooltip* test_tooltip_;
-  scoped_ptr<TooltipControllerTestHelper> helper_;
-  scoped_ptr<ui::test::EventGenerator> generator_;
-  scoped_ptr<views::Widget> widget_;
+  std::unique_ptr<TooltipControllerTestHelper> helper_;
+  std::unique_ptr<ui::test::EventGenerator> generator_;
+  std::unique_ptr<views::Widget> widget_;
   TooltipTestView* view_;
 
  private:
-  scoped_ptr<TooltipController> controller_;
-  scoped_ptr<wm::WMState> wm_state_;
+  std::unique_ptr<TooltipController> controller_;
+  std::unique_ptr<wm::WMState> wm_state_;
 
 #if defined(OS_WIN)
   ui::ScopedOleInitializer ole_initializer_;
 #endif
 
   aura::Window* GetRootWindow() { return GetWindow()->GetRootWindow(); }
 
   DISALLOW_COPY_AND_ASSIGN(TooltipControllerTest3);
 };
 
@@ skipping 98 matching lines @@
   helper_->FireTooltipTimer();
   tooltip_bounds1 = test_tooltip_->location();
 
   EXPECT_NE(tooltip_bounds1_1, tooltip_bounds1);
   EXPECT_EQ(reference_string, helper_->GetTooltipText());
 }
 
 }  // namespace test
 }  // namespace corewm
 }  // namespace views