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

ui/keyboard/keyboard_controller.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 "ui/aura/window.h"
 #include "ui/aura/window_delegate.h"
@@ skipping 257 matching lines @@
 }
 
 void KeyboardController::AddObserver(KeyboardControllerObserver* observer) {
   observer_list_.AddObserver(observer);
 }
 
 void KeyboardController::RemoveObserver(KeyboardControllerObserver* observer) {
   observer_list_.RemoveObserver(observer);
 }
 
-void KeyboardController::ShowAndLockKeyboard() {
-  set_lock_keyboard(true);
-  OnShowImeIfNeeded();
+void KeyboardController::ShowKeyboard(bool lock) {
+  set_lock_keyboard(lock);
+  ShowKeyboardInternal();
 }
 
 void KeyboardController::OnWindowHierarchyChanged(
     const HierarchyChangeParams& params) {
   if (params.new_parent && params.target == container_.get())
     OnTextInputStateChanged(proxy_->GetInputMethod()->GetTextInputClient());
 }
 
 void KeyboardController::Reload() {
   // Makes sure the keyboard window is initialized.
   proxy_->GetKeyboardWindow();
   proxy_->ReloadKeyboardIfNeeded();
 }
 
 void KeyboardController::OnTextInputStateChanged(
     const ui::TextInputClient* client) {
   if (!container_.get())
     return;
 
   if (IsKeyboardUsabilityExperimentEnabled()) {
-    OnShowImeIfNeeded();
+    ShowKeyboardInternal();
     return;
   }
 
   type_ = client ? client->GetTextInputType() : ui::TEXT_INPUT_TYPE_NONE;
 
   if (type_ == ui::TEXT_INPUT_TYPE_NONE && !lock_keyboard_) {
     if (keyboard_visible_) {
       // Set the visibility state here so that any queries for visibility
       // before the timer fires returns the correct future value.
       keyboard_visible_ = false;
@@ skipping 18 matching lines @@
   }
 }
 
 void KeyboardController::OnInputMethodDestroyed(
     const ui::InputMethod* input_method) {
   DCHECK_EQ(input_method_, input_method);
   input_method_ = NULL;
 }
 
 void KeyboardController::OnShowImeIfNeeded() {
+  ShowKeyboardInternal();
+}
+
+void KeyboardController::ShowKeyboardInternal() {
   if (!container_.get())
     return;
 
   if (container_->children().empty()) {
     keyboard::MarkKeyboardLoadStarted();
     aura::Window* keyboard = proxy_->GetKeyboardWindow();
     keyboard->Show();
     container_->AddChild(keyboard);
     keyboard->set_owned_by_parent(false);
   }
 
   proxy_->ReloadKeyboardIfNeeded();
 
-  if (keyboard_visible_)
+  if (keyboard_visible_ || proxy_->GetKeyboardWindow()->bounds().height() == 0)
     return;
 
   keyboard_visible_ = true;
 
   // If the controller is in the process of hiding the keyboard, do not log
   // the stat here since the keyboard will not actually be shown.
   if (!WillHideKeyboard())
     keyboard::LogKeyboardControlEvent(keyboard::KEYBOARD_CONTROL_SHOW);
 
   weak_factory_.InvalidateWeakPtrs();
 
   // If |container_| has hide animation, its visibility is set to false when
   // hide animation finished. So even if the container is visible at this
   // point, it may in the process of hiding. We still need to show keyboard
   // container in this case.
   if (container_->IsVisible() &&
       !container_->layer()->GetAnimator()->is_animating())
     return;
 
-  ShowKeyboard();
-}
-
-void KeyboardController::ShowKeyboard() {
   ToggleTouchEventLogging(false);
   ui::LayerAnimator* container_animator = container_->layer()->GetAnimator();
 
   // If the container is not animating, makes sure the position and opacity
   // are at begin states for animation.
   if (!container_animator->is_animating()) {
     gfx::Transform transform;
     transform.Translate(0, proxy_->GetKeyboardWindow()->bounds().height());
     container_->SetTransform(transform);
     container_->layer()->SetOpacity(kAnimationStartOrAfterHideOpacity);
   }
 
   container_animator->set_preemption_strategy(
       ui::LayerAnimator::IMMEDIATELY_ANIMATE_TO_NEW_TARGET);
   animation_observer_.reset(new CallbackAnimationObserver(
       container_animator,
       base::Bind(&KeyboardController::ShowAnimationFinished,
                  base::Unretained(this))));
   container_animator->AddObserver(animation_observer_.get());
 
+  proxy_->ShowKeyboardContainer(container_.get());
+
   {
     // Scope the following animation settings as we don't want to animate
     // visibility change that triggered by a call to the base class function
     // ShowKeyboardContainer with these settings. The container should become
     // visible immediately.
     ui::ScopedLayerAnimationSettings settings(container_animator);
     settings.SetTweenType(gfx::Tween::EASE_IN);
     settings.SetTransitionDuration(
         base::TimeDelta::FromMilliseconds(kAnimationDurationMs));
     container_->SetTransform(gfx::Transform());
     container_->layer()->SetOpacity(1.0);
   }
-
-  proxy_->ShowKeyboardContainer(container_.get());
 }
 
 bool KeyboardController::WillHideKeyboard() const {
   return weak_factory_.HasWeakPtrs();
 }
 
 void KeyboardController::ShowAnimationFinished() {
   // Notify observers after animation finished to prevent reveal desktop
   // background during animation.
   NotifyKeyboardBoundsChanging(proxy_->GetKeyboardWindow()->bounds());
   proxy_->EnsureCaretInWorkArea();
 }
 
 void KeyboardController::HideAnimationFinished() {
   proxy_->HideKeyboardContainer(container_.get());
 }
 
 }  // namespace keyboard