Keep virtual keyboard visibility the same after enable an IME in a different extension

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 "content/public/browser/render_widget_host.h"
 #include "content/public/browser/render_widget_host_iterator.h"
@@ skipping 188 matching lines @@
 void CallbackAnimationObserver::OnLayerAnimationAborted(
     ui::LayerAnimationSequence* seq) {
   animator_->RemoveObserver(this);
 }
 
 class WindowBoundsChangeObserver : public aura::WindowObserver {
  public:
   virtual void OnWindowBoundsChanged(aura::Window* window,
                                      const gfx::Rect& old_bounds,
                                      const gfx::Rect& new_bounds) OVERRIDE;
+  virtual void OnWindowDestroyed(aura::Window* window) OVERRIDE;
 };
 
 void WindowBoundsChangeObserver::OnWindowBoundsChanged(aura::Window* window,
     const gfx::Rect& old_bounds, const gfx::Rect& new_bounds) {
   KeyboardController* controller =  KeyboardController::GetInstance();
   if (controller)
     controller->UpdateWindowInsets(window);
 }
 
+void WindowBoundsChangeObserver::OnWindowDestroyed(aura::Window* window) {
+   if (window->HasObserver(this))
+     window->RemoveObserver(this);
+}
+
 // static
 KeyboardController* KeyboardController::instance_ = NULL;
 
 KeyboardController::KeyboardController(KeyboardControllerProxy* proxy)
     : proxy_(proxy),
       input_method_(NULL),
       keyboard_visible_(false),
       lock_keyboard_(false),
       type_(ui::TEXT_INPUT_TYPE_NONE),
       weak_factory_(this) {
@@ skipping 53 matching lines @@
       scoped_ptr<content::RenderWidgetHostIterator> widgets(
           content::RenderWidgetHost::GetRenderWidgetHosts());
       aura::Window *keyboard_window = proxy_->GetKeyboardWindow();
       aura::Window *root_window = keyboard_window->GetRootWindow();
       while (content::RenderWidgetHost* widget = widgets->GetNextHost()) {
         content::RenderWidgetHostView* view = widget->GetView();
         // Can be NULL, e.g. if the RenderWidget is being destroyed or
         // the render process crashed.
         if (view) {
           aura::Window *window = view->GetNativeView();
-          if (window != keyboard_window &&
-              window->GetRootWindow() == root_window) {
+          if (window->GetRootWindow() == root_window) {

[kevers, 2014/08/20 14:02:29]

Not clear to me why we need a bounds changed observer on the keyboard window
itself since it should never have insets for overscrolling.

[bshe, 2014/08/20 14:59:59]

Sorry. It shouldn't be removed. I thought I could just do the check in
AddBoundsChangedObserver. But it is not exactly the same.

             gfx::Rect window_bounds = window->GetBoundsInScreen();
             gfx::Rect intersect = gfx::IntersectRects(window_bounds,
                                                       new_bounds);
             int overlap = intersect.height();
             if (overlap > 0 && overlap < window_bounds.height())
               view->SetInsets(gfx::Insets(0, 0, overlap, 0));
             else
               view->SetInsets(gfx::Insets());
             AddBoundsChangedObserver(window);
           }
@@ skipping 48 matching lines @@
   ShowKeyboardInternal();
 }
 
 void KeyboardController::OnWindowHierarchyChanged(
     const HierarchyChangeParams& params) {
   if (params.new_parent && params.target == container_.get())
     OnTextInputStateChanged(proxy_->GetInputMethod()->GetTextInputClient());
 }
 
 void KeyboardController::Reload() {
-  if (proxy_->HasKeyboardWindow())
+  if (proxy_->HasKeyboardWindow()) {
+    // A reload should never try to show virtual keyboard. If keyboard is not
+    // visible before reload, it should keep invisible after reload.
+    wait_for_resize_to_show_ = false;
     proxy_->ReloadKeyboardIfNeeded();
+  }
 }
 
 void KeyboardController::OnTextInputStateChanged(
     const ui::TextInputClient* client) {
   if (!container_.get())
     return;
 
   if (IsKeyboardUsabilityExperimentEnabled()) {
     ShowKeyboardInternal();
     return;
@@ skipping 71 matching lines @@
   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_ || proxy_->GetKeyboardWindow()->bounds().height() == 0)
+  if (keyboard_visible_) {
     return;
+  } else if (proxy_->GetKeyboardWindow()->bounds().height() == 0) {
+    wait_for_resize_to_show_ = true;
+    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();
 
@@ skipping 65 matching lines @@
   NotifyKeyboardBoundsChanging(proxy_->GetKeyboardWindow()->bounds());
   proxy_->EnsureCaretInWorkArea();
 }
 
 void KeyboardController::HideAnimationFinished() {
   proxy_->HideKeyboardContainer(container_.get());
 }
 
 void KeyboardController::AddBoundsChangedObserver(aura::Window* window) {
   aura::Window* target_window = GetFrameWindow(window);
-  if (target_window &&
+  if (target_window && target_window != proxy_->GetKeyboardWindow() &&
       !target_window->HasObserver(window_bounds_observer_.get())) {
     target_window->AddObserver(window_bounds_observer_.get());
   }
 }
 
 void KeyboardController::RemoveBoundsChangedObserver(aura::Window* window) {
   aura::Window* target_window = GetFrameWindow(window);
   if (target_window &&
       target_window->HasObserver(window_bounds_observer_.get())) {
     target_window->RemoveObserver(window_bounds_observer_.get());
   }
 }
 
 }  // namespace keyboard