Remove native VK window height logic and wait for resizeTo to setup VK window height

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 "base/bind.h"
 #include "base/command_line.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/event_generator.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"
 #include "ui/base/ime/input_method_factory.h"
 #include "ui/base/ime/text_input_client.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/gfx/rect.h"
 #include "ui/keyboard/keyboard_controller.h"
 #include "ui/keyboard/keyboard_controller_observer.h"
 #include "ui/keyboard/keyboard_controller_proxy.h"
 #include "ui/keyboard/keyboard_switches.h"
+#include "ui/keyboard/keyboard_util.h"
 
 namespace keyboard {
 namespace {
 
 // Steps a layer animation until it is completed. Animations must be enabled.
 void RunAnimationForLayer(ui::Layer* layer) {
   // Animations must be enabled for stepping to work.
   ASSERT_NE(ui::ScopedAnimationDurationScaleMode::duration_scale_mode(),
             ui::ScopedAnimationDurationScaleMode::ZERO_DURATION);
 
@@ skipping 146 matching lines @@
 
   void ShowKeyboard() {
     ui::DummyTextInputClient test_text_input_client(ui::TEXT_INPUT_TYPE_TEXT);
     SetFocus(&test_text_input_client);
   }
 
  protected:
   void SetFocus(ui::TextInputClient* client) {
     ui::InputMethod* input_method = proxy()->GetInputMethod();
     input_method->SetFocusedTextInputClient(client);
-    if (client && client->GetTextInputType() != ui::TEXT_INPUT_TYPE_NONE)
+    if (client && client->GetTextInputType() != ui::TEXT_INPUT_TYPE_NONE) {
       input_method->ShowImeIfNeeded();
+      if (proxy_->GetKeyboardWindow()->bounds().height() == 0) {
+        // Set initial bounds for test keyboard window.
+        proxy_->GetKeyboardWindow()->SetBounds(
+            KeyboardBoundsFromWindowBounds(
+                controller()->GetContainerWindow()->bounds(), 100));
+      }
+    }
   }
 
   bool WillHideKeyboard() {
     return controller_->WillHideKeyboard();
   }
 
   base::MessageLoopForUI message_loop_;
   scoped_ptr<aura::test::AuraTestHelper> aura_test_helper_;
   scoped_ptr<TestFocusController> focus_controller_;
 
  private:
   KeyboardControllerProxy* proxy_;
   scoped_ptr<KeyboardController> controller_;
 
   DISALLOW_COPY_AND_ASSIGN(KeyboardControllerTest);
 };
 
 TEST_F(KeyboardControllerTest, KeyboardSize) {
   aura::Window* container(controller()->GetContainerWindow());
-  gfx::Rect bounds(0, 0, 100, 100);
-  container->SetBounds(bounds);
+  aura::Window* keyboard(proxy()->GetKeyboardWindow());
+  container->SetBounds(gfx::Rect(0, 0, 200, 100));
 
-  const gfx::Rect& before_bounds = proxy()->GetKeyboardWindow()->bounds();
+  container->AddChild(keyboard);
+  const gfx::Rect& before_bounds = keyboard->bounds();
+  // The initial keyboard should be positioned at the bottom of container and
+  // has 0 height.
+  ASSERT_EQ(gfx::Rect(0, 100, 200, 0), before_bounds);
+
   gfx::Rect new_bounds(
-      before_bounds.x(), before_bounds.y(),
-      before_bounds.width() / 2, before_bounds.height() / 2);
+      before_bounds.x(), before_bounds.y() - 50,
+      before_bounds.width(), 50);
 
-  // The KeyboardController's LayoutManager shouldn't let this happen
-  proxy()->GetKeyboardWindow()->SetBounds(new_bounds);
-  ASSERT_EQ(before_bounds, proxy()->GetKeyboardWindow()->bounds());
+  keyboard->SetBounds(new_bounds);
+  ASSERT_EQ(new_bounds, keyboard->bounds());
+
+  // Mock a screen rotation.
+  container->SetBounds(gfx::Rect(0, 0, 100, 200));
+  // The above call should resize keyboard to new width while keeping the old
+  // height.
+  ASSERT_EQ(gfx::Rect(0, 150, 100, 50), keyboard->bounds());
 }
 
 // Tests that tapping/clicking inside the keyboard does not give it focus.
 TEST_F(KeyboardControllerTest, ClickDoesNotFocusKeyboard) {
   const gfx::Rect& root_bounds = root_window()->bounds();
   aura::test::EventCountDelegate delegate;
   scoped_ptr<aura::Window> window(new aura::Window(&delegate));
   window->Init(aura::WINDOW_LAYER_NOT_DRAWN);
   window->SetBounds(root_bounds);
   root_window()->AddChild(window.get());
@@ skipping 148 matching lines @@
 
   // Keyboard should hide when focus on no input client.
   SetFocus(&no_input_client_1);
   EXPECT_TRUE(WillHideKeyboard());
 
   // Wait for hide keyboard to finish.
   base::MessageLoop::current()->Run();
   EXPECT_FALSE(keyboard_container->IsVisible());
 }
 
-TEST_F(KeyboardControllerTest, KeyboardResizingFromContents) {
-  aura::Window* keyboard_container = controller()->GetContainerWindow();
-  aura::Window* keyboard_window = proxy()->GetKeyboardWindow();
-  keyboard_container->SetBounds(gfx::Rect(800, 600));
-  keyboard_container->AddChild(keyboard_window);
-
-  int original_height = keyboard_window->bounds().height();
-
-  // Resizes from contents when flag is unset.
-  keyboard_window->SetBounds(gfx::Rect(100, 80));
-  EXPECT_EQ(original_height, keyboard_window->bounds().height());
-
-  // Resizes from contents when flag is set.
-  proxy()->set_resizing_from_contents(true);
-  keyboard_window->SetBounds(gfx::Rect(100, 80));
-  EXPECT_EQ(80, keyboard_window->bounds().height());
-
-  // Resizes from container when flag is set.
-  keyboard_container->SetBounds(gfx::Rect(400, 300));
-  EXPECT_EQ(80, keyboard_window->bounds().height());
-
-  // Resizes from container when flag is unset.
-  proxy()->set_resizing_from_contents(false);
-  keyboard_container->SetBounds(gfx::Rect(800, 600));
-  EXPECT_EQ(original_height, keyboard_window->bounds().height());
-}
-
 class KeyboardControllerAnimationTest : public KeyboardControllerTest,
                                         public KeyboardControllerObserver {
  public:
   KeyboardControllerAnimationTest() {}
   virtual ~KeyboardControllerAnimationTest() {}
 
   virtual void SetUp() OVERRIDE {
     // We cannot short-circuit animations for this test.
     ui::ScopedAnimationDurationScaleMode normal_duration_mode(
         ui::ScopedAnimationDurationScaleMode::NORMAL_DURATION);
@@ skipping 124 matching lines @@
   SetFocus(&input_client);
   EXPECT_TRUE(keyboard_container->IsVisible());
 
   SetFocus(&no_input_client);
   // Keyboard should not hide itself after lost focus.
   EXPECT_TRUE(keyboard_container->IsVisible());
   EXPECT_FALSE(WillHideKeyboard());
 }
 
 }  // namespace keyboard