Extract content dependency from keyboard code

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 "base/bind.h"
 #include "base/command_line.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop.h"
@@ skipping 10 matching lines @@
 #include "ui/base/ime/text_input_client.h"
 #include "ui/compositor/compositor.h"
 #include "ui/compositor/layer_type.h"
 #include "ui/compositor/scoped_animation_duration_scale_mode.h"
 #include "ui/compositor/test/context_factories_for_test.h"
 #include "ui/compositor/test/layer_animator_test_controller.h"
 #include "ui/events/event_utils.h"
 #include "ui/events/test/event_generator.h"
 #include "ui/gfx/geometry/rect.h"
 #include "ui/keyboard/keyboard_controller_observer.h"
-#include "ui/keyboard/keyboard_controller_proxy.h"
+#include "ui/keyboard/keyboard_ui.h"
 #include "ui/keyboard/keyboard_util.h"
 #include "ui/wm/core/default_activation_client.h"
 
 namespace keyboard {
 namespace {
 
 const int kDefaultVirtualKeyboardHeight = 100;
 
 // Verify if the |keyboard| window covers the |container| window completely.
 void VerifyKeyboardWindowSize(aura::Window* container, aura::Window* keyboard) {
@@ skipping 37 matching lines @@
     if (event->type() == ui::ET_MOUSE_PRESSED ||
         event->type() == ui::ET_TOUCH_PRESSED) {
       aura::client::GetFocusClient(target)->FocusWindow(target);
     }
   }
 
   aura::Window* root_;
   DISALLOW_COPY_AND_ASSIGN(TestFocusController);
 };
 
-class TestKeyboardControllerProxy : public KeyboardControllerProxy {
+class TestKeyboardUI : public KeyboardUI {
  public:
-  TestKeyboardControllerProxy(ui::InputMethod* input_method)
-      : KeyboardControllerProxy(nullptr),
-        input_method_(input_method) {}
-
-  ~TestKeyboardControllerProxy() override {
+  TestKeyboardUI(ui::InputMethod* input_method) : input_method_(input_method) {}
+  ~TestKeyboardUI() override {
     // Destroy the window before the delegate.
     window_.reset();
   }
 
-  // Overridden from KeyboardControllerProxy:
+  // Overridden from KeyboardUI:
   bool HasKeyboardWindow() const override { return window_; }
   aura::Window* GetKeyboardWindow() override {
     if (!window_) {
       window_.reset(new aura::Window(&delegate_));
       window_->Init(ui::LAYER_NOT_DRAWN);
       window_->set_owned_by_parent(false);
     }
     return window_.get();
   }
   ui::InputMethod* GetInputMethod() override { return input_method_; }
-  void RequestAudioInput(
-      content::WebContents* web_contents,
-      const content::MediaStreamRequest& request,
-      const content::MediaResponseCallback& callback) override {
-    return;
-  }
-  void LoadSystemKeyboard() override{};
-  void ReloadKeyboardIfNeeded() override{};
+  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_;
   aura::test::TestWindowDelegate delegate_;
   ui::InputMethod* input_method_;
 
-  DISALLOW_COPY_AND_ASSIGN(TestKeyboardControllerProxy);
+  DISALLOW_COPY_AND_ASSIGN(TestKeyboardUI);
 };
 
 // Keeps a count of all the events a window receives.
 class EventObserver : public ui::EventHandler {
  public:
   EventObserver() {}
   ~EventObserver() override {}
 
   int GetEventCount(ui::EventType type) {
     return event_counts_[type];
@@ skipping 26 matching lines @@
   aura::Window* window_;
 
   DISALLOW_COPY_AND_ASSIGN(KeyboardContainerObserver);
 };
 
 }  // namespace
 
 class KeyboardControllerTest : public testing::Test,
                                public KeyboardControllerObserver {
  public:
-  KeyboardControllerTest() : number_of_calls_(0), proxy_(nullptr) {}
+  KeyboardControllerTest() : number_of_calls_(0), ui_(nullptr) {}
   ~KeyboardControllerTest() override {}
 
   void SetUp() override {
     // The ContextFactory must exist before any Compositors are created.
     bool enable_pixel_output = false;
     ui::ContextFactory* context_factory =
         ui::InitializeContextFactoryForTests(enable_pixel_output);
 
     ui::SetUpInputMethodFactoryForTesting();
     aura_test_helper_.reset(new aura::test::AuraTestHelper(&message_loop_));
     aura_test_helper_->SetUp(context_factory);
     new wm::DefaultActivationClient(aura_test_helper_->root_window());
     focus_controller_.reset(new TestFocusController(root_window()));
-    proxy_ = new TestKeyboardControllerProxy(
-        aura_test_helper_->host()->GetInputMethod());
-    controller_.reset(new KeyboardController(proxy_));
+    ui_ = new TestKeyboardUI(aura_test_helper_->host()->GetInputMethod());
+    controller_.reset(new KeyboardController(ui_));
     controller()->AddObserver(this);
   }
 
   void TearDown() override {
     controller()->RemoveObserver(this);
     controller_.reset();
     focus_controller_.reset();
     aura_test_helper_->TearDown();
     ui::TerminateContextFactoryForTests();
   }
 
   aura::Window* root_window() { return aura_test_helper_->root_window(); }
-  KeyboardControllerProxy* proxy() { return proxy_; }
+  KeyboardUI* ui() { return ui_; }
   KeyboardController* controller() { return controller_.get(); }
 
   void ShowKeyboard() {
     test_text_input_client_.reset(
         new ui::DummyTextInputClient(ui::TEXT_INPUT_TYPE_TEXT));
     SetFocus(test_text_input_client_.get());
   }
 
   void MockRotateScreen() {
     const gfx::Rect root_bounds = root_window()->bounds();
     controller_->OnWindowBoundsChanged(root_window(), gfx::Rect(),
                                        gfx::Rect(0,
                                                  0,
                                                  root_bounds.height(),
                                                  root_bounds.width()));
   }
 
  protected:
   // KeyboardControllerObserver overrides
   void OnKeyboardBoundsChanging(const gfx::Rect& new_bounds) override {
     notified_bounds_ = new_bounds;
     number_of_calls_++;
   }
 
   int number_of_calls() const { return number_of_calls_; }
 
   const gfx::Rect& notified_bounds() { return notified_bounds_; }
 
   void SetFocus(ui::TextInputClient* client) {
-    ui::InputMethod* input_method = proxy()->GetInputMethod();
+    ui::InputMethod* input_method = ui()->GetInputMethod();
     input_method->SetFocusedTextInputClient(client);
     if (client && client->GetTextInputType() != ui::TEXT_INPUT_TYPE_NONE) {
       input_method->ShowImeIfNeeded();
-      if (proxy_->GetKeyboardWindow()->bounds().height() == 0) {
+      if (ui_->GetKeyboardWindow()->bounds().height() == 0) {
         // Set initial bounds for test keyboard window.
-        proxy_->GetKeyboardWindow()->SetBounds(
+        ui_->GetKeyboardWindow()->SetBounds(
             FullWidthKeyboardBoundsFromRootBounds(
                 root_window()->bounds(), kDefaultVirtualKeyboardHeight));
       }
     }
   }
 
   bool WillHideKeyboard() {
     return controller_->WillHideKeyboard();
   }
 
   bool ShouldEnableInsets(aura::Window* window) {
-    return controller_->ShouldEnableInsets(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_;
 
  private:
   int number_of_calls_;
   gfx::Rect notified_bounds_;
-  KeyboardControllerProxy* proxy_;
+  KeyboardUI* ui_;
   scoped_ptr<KeyboardController> controller_;
   scoped_ptr<ui::TextInputClient> test_text_input_client_;
   DISALLOW_COPY_AND_ASSIGN(KeyboardControllerTest);
 };
 
 TEST_F(KeyboardControllerTest, KeyboardSize) {
   aura::Window* container(controller()->GetContainerWindow());
-  aura::Window* keyboard(proxy()->GetKeyboardWindow());
+  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();
   // The container should be positioned at the bottom of screen and has 0
   // height.
   ASSERT_EQ(gfx::Rect(), initial_bounds);
   VerifyKeyboardWindowSize(container, keyboard);
 
 
@@ skipping 18 matching lines @@
   ASSERT_EQ(gfx::Rect(0,
                       screen_bounds.width() - 50,
                       screen_bounds.height(),
                       50),
             container->bounds());
   VerifyKeyboardWindowSize(container, keyboard);
 }
 
 TEST_F(KeyboardControllerTest, FloatingKeyboardSize) {
   aura::Window* container(controller()->GetContainerWindow());
-  aura::Window* keyboard(proxy()->GetKeyboardWindow());
+  aura::Window* keyboard(ui()->GetKeyboardWindow());
   gfx::Rect screen_bounds = root_window()->bounds();
   root_window()->AddChild(container);
   controller()->SetKeyboardMode(FLOATING);
   container->AddChild(keyboard);
   gfx::Rect new_bounds(0, 50, 50, 50);
   keyboard->SetBounds(new_bounds);
   ASSERT_EQ(new_bounds, container->bounds());
   VerifyKeyboardWindowSize(container, keyboard);
 }
 
@@ skipping 89 matching lines @@
   root_window()->AddChild(keyboard_container);
 
   // Enable touch keyboard / overscroll mode to test insets.
   keyboard::SetTouchKeyboardEnabled(true);
   EXPECT_TRUE(keyboard::IsKeyboardOverscrollEnabled());
 
   SetFocus(&input_client);
   SetFocus(&no_input_client);
   // Insets should not be enabled for new windows while keyboard is in the
   // process of hiding when overscroll is enabled.
-  EXPECT_FALSE(ShouldEnableInsets(proxy()->GetKeyboardWindow()));
+  EXPECT_FALSE(ShouldEnableInsets(ui()->GetKeyboardWindow()));
   // Cancel keyboard hide.
   SetFocus(&input_client);
   // Insets should be enabled for new windows as hide was cancelled.
-  EXPECT_TRUE(ShouldEnableInsets(proxy()->GetKeyboardWindow()));
+  EXPECT_TRUE(ShouldEnableInsets(ui()->GetKeyboardWindow()));
 }
 
 // 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) {
   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);
@@ skipping 105 matching lines @@
   void TearDown() override {
     KeyboardControllerTest::TearDown();
   }
 
  protected:
   aura::Window* keyboard_container() {
     return controller()->GetContainerWindow();
   }
 
   aura::Window* keyboard_window() {
-    return proxy()->GetKeyboardWindow();
+    return ui()->GetKeyboardWindow();
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(KeyboardControllerAnimationTest);
 };
 
 // Tests virtual keyboard has correct show and hide animation.
 TEST_F(KeyboardControllerAnimationTest, ContainerAnimation) {
   ui::Layer* layer = keyboard_container()->layer();
   ShowKeyboard();
@@ skipping 50 matching lines @@
   // Before hide animation finishes, show keyboard again.
   ShowKeyboard();
   RunAnimationForLayer(layer);
   EXPECT_TRUE(keyboard_container()->IsVisible());
   EXPECT_TRUE(keyboard_window()->IsVisible());
   EXPECT_EQ(1.0, layer->opacity());
   EXPECT_EQ(gfx::Transform(), layer->transform());
 }
 
 }  // namespace keyboard