Replace scoped_ptr with std::unique_ptr in //ui

ui/keyboard/keyboard_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/keyboard/keyboard_controller.h"
 
+#include <memory>
+
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/macros.h"
-#include "base/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "ui/aura/client/focus_client.h"
 #include "ui/aura/layout_manager.h"
 #include "ui/aura/test/aura_test_helper.h"
 #include "ui/aura/test/test_window_delegate.h"
 #include "ui/aura/window.h"
 #include "ui/aura/window_event_dispatcher.h"
 #include "ui/base/ime/dummy_text_input_client.h"
 #include "ui/base/ime/input_method.h"
@@ skipping 87 matching lines @@
     }
     return window_.get();
   }
   ui::InputMethod* GetInputMethod() override { return input_method_; }
   void SetUpdateInputType(ui::TextInputType type) override {}
   void ReloadKeyboardIfNeeded() override {};
   void InitInsets(const gfx::Rect& keyboard_bounds) override {}
   void ResetInsets() override {}
 
  private:
-  scoped_ptr<aura::Window> window_;
+  std::unique_ptr<aura::Window> window_;
   aura::test::TestWindowDelegate delegate_;
   ui::InputMethod* input_method_;
 
   DISALLOW_COPY_AND_ASSIGN(TestKeyboardUI);
 };
 
 // Keeps a count of all the events a window receives.
 class EventObserver : public ui::EventHandler {
  public:
   EventObserver() {}
@@ skipping 114 matching lines @@
 
   bool ShouldEnableInsets(aura::Window* window) {
     aura::Window* keyboard_window = ui_->GetKeyboardWindow();
     return (keyboard_window->GetRootWindow() == window->GetRootWindow() &&
             keyboard::IsKeyboardOverscrollEnabled() &&
             keyboard_window->IsVisible() &&
             controller_->keyboard_visible());
   }
 
   base::MessageLoopForUI message_loop_;
-  scoped_ptr<aura::test::AuraTestHelper> aura_test_helper_;
-  scoped_ptr<TestFocusController> focus_controller_;
+  std::unique_ptr<aura::test::AuraTestHelper> aura_test_helper_;
+  std::unique_ptr<TestFocusController> focus_controller_;
 
  private:
   int number_of_calls_;
   gfx::Rect notified_bounds_;
   KeyboardUI* ui_;
-  scoped_ptr<KeyboardController> controller_;
-  scoped_ptr<ui::TextInputClient> test_text_input_client_;
+  std::unique_ptr<KeyboardController> controller_;
+  std::unique_ptr<ui::TextInputClient> test_text_input_client_;
   DISALLOW_COPY_AND_ASSIGN(KeyboardControllerTest);
 };
 
 TEST_F(KeyboardControllerTest, KeyboardSize) {
   aura::Window* container(controller()->GetContainerWindow());
   aura::Window* keyboard(ui()->GetKeyboardWindow());
   gfx::Rect screen_bounds = root_window()->bounds();
   root_window()->AddChild(container);
   container->AddChild(keyboard);
   const gfx::Rect& initial_bounds = container->bounds();
@@ skipping 40 matching lines @@
   keyboard->SetBounds(new_bounds);
   ASSERT_EQ(new_bounds, container->bounds());
   VerifyKeyboardWindowSize(container, keyboard);
 }
 
 // Tests that tapping/clicking inside the keyboard does not give it focus.
 TEST_F(KeyboardControllerTest, ClickDoesNotFocusKeyboard) {
   keyboard::SetAccessibilityKeyboardEnabled(true);
   const gfx::Rect& root_bounds = root_window()->bounds();
   aura::test::EventCountDelegate delegate;
-  scoped_ptr<aura::Window> window(new aura::Window(&delegate));
+  std::unique_ptr<aura::Window> window(new aura::Window(&delegate));
   window->Init(ui::LAYER_NOT_DRAWN);
   window->SetBounds(root_bounds);
   root_window()->AddChild(window.get());
   window->Show();
   window->Focus();
 
   aura::Window* keyboard_container(controller()->GetContainerWindow());
 
   root_window()->AddChild(keyboard_container);
   keyboard_container->Show();
@@ skipping 29 matching lines @@
 
 TEST_F(KeyboardControllerTest, VisibilityChangeWithTextInputTypeChange) {
   keyboard::SetAccessibilityKeyboardEnabled(true);
   ui::DummyTextInputClient input_client_0(ui::TEXT_INPUT_TYPE_TEXT);
   ui::DummyTextInputClient input_client_1(ui::TEXT_INPUT_TYPE_TEXT);
   ui::DummyTextInputClient input_client_2(ui::TEXT_INPUT_TYPE_TEXT);
   ui::DummyTextInputClient no_input_client_0(ui::TEXT_INPUT_TYPE_NONE);
   ui::DummyTextInputClient no_input_client_1(ui::TEXT_INPUT_TYPE_NONE);
 
   aura::Window* keyboard_container(controller()->GetContainerWindow());
-  scoped_ptr<KeyboardContainerObserver> keyboard_container_observer(
+  std::unique_ptr<KeyboardContainerObserver> keyboard_container_observer(
       new KeyboardContainerObserver(keyboard_container));
   root_window()->AddChild(keyboard_container);
 
   SetFocus(&input_client_0);
 
   EXPECT_TRUE(keyboard_container->IsVisible());
 
   SetFocus(&no_input_client_0);
   // Keyboard should not immediately hide itself. It is delayed to avoid layout
   // flicker when the focus of input field quickly change.
@@ skipping 43 matching lines @@
 
 // Verify switch to FLOATING mode will reset the overscroll or resize and when
 // in FLOATING mode, overscroll or resize wont be triggered.
 TEST_F(KeyboardControllerTest, FloatingKeyboardDontOverscrollOrResize) {
   keyboard::SetAccessibilityKeyboardEnabled(true);
   ui::DummyTextInputClient input_client(ui::TEXT_INPUT_TYPE_TEXT);
   ui::DummyTextInputClient no_input_client(ui::TEXT_INPUT_TYPE_NONE);
 
   aura::Window* container(controller()->GetContainerWindow());
   root_window()->AddChild(container);
-  scoped_ptr<KeyboardContainerObserver> keyboard_container_observer(
+  std::unique_ptr<KeyboardContainerObserver> keyboard_container_observer(
       new KeyboardContainerObserver(container));
   gfx::Rect screen_bounds = root_window()->bounds();
   keyboard::SetTouchKeyboardEnabled(true);
 
   SetFocus(&input_client);
   gfx::Rect expected_bounds(
       0, screen_bounds.height() - kDefaultVirtualKeyboardHeight,
       screen_bounds.width(), kDefaultVirtualKeyboardHeight);
   // Verify overscroll or resize is in effect.
   EXPECT_EQ(expected_bounds, notified_bounds());
@@ skipping 38 matching lines @@
 }
 
 TEST_F(KeyboardControllerTest, AlwaysVisibleWhenLocked) {
   keyboard::SetAccessibilityKeyboardEnabled(true);
   ui::DummyTextInputClient input_client_0(ui::TEXT_INPUT_TYPE_TEXT);
   ui::DummyTextInputClient input_client_1(ui::TEXT_INPUT_TYPE_TEXT);
   ui::DummyTextInputClient no_input_client_0(ui::TEXT_INPUT_TYPE_NONE);
   ui::DummyTextInputClient no_input_client_1(ui::TEXT_INPUT_TYPE_NONE);
 
   aura::Window* keyboard_container(controller()->GetContainerWindow());
-  scoped_ptr<KeyboardContainerObserver> keyboard_container_observer(
+  std::unique_ptr<KeyboardContainerObserver> keyboard_container_observer(
       new KeyboardContainerObserver(keyboard_container));
   root_window()->AddChild(keyboard_container);
 
   SetFocus(&input_client_0);
 
   EXPECT_TRUE(keyboard_container->IsVisible());
 
   // Lock keyboard.
   controller()->set_lock_keyboard(true);
 
@@ skipping 131 matching lines @@
   // Mock set keyboard size from javascript side. In floating mode, virtual
   // keyboard's size is decided by client.
   gfx::Rect new_bounds(0, 50, 50, 50);
   keyboard->SetBounds(new_bounds);
   ASSERT_EQ(new_bounds, container->bounds());
   EXPECT_TRUE(keyboard->IsVisible());
   EXPECT_TRUE(container->IsVisible());
 }
 
 }  // namespace keyboard