Delay virtual keyboard hiding for 100ms

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 "ui/aura/layout_manager.h"
 #include "ui/aura/window.h"
 #include "ui/aura/window_delegate.h"
 #include "ui/base/hit_test.h"
 #include "ui/base/ime/input_method.h"
 #include "ui/base/ime/text_input_client.h"
 #include "ui/base/ime/text_input_type.h"
 #include "ui/gfx/path.h"
 #include "ui/gfx/rect.h"
 #include "ui/gfx/skia_util.h"
 #include "ui/keyboard/keyboard_controller_observer.h"
 #include "ui/keyboard/keyboard_controller_proxy.h"
 
 namespace {
 
+const int kHideKeyboardDelayMs = 100;
+
 gfx::Rect KeyboardBoundsFromWindowBounds(const gfx::Rect& window_bounds) {
   const float kKeyboardHeightRatio = 0.3f;
   return gfx::Rect(
       window_bounds.x(),
       window_bounds.y() + window_bounds.height() * (1 - kKeyboardHeightRatio),
       window_bounds.width(),
       window_bounds.height() * kKeyboardHeightRatio);
 }
 
 // The KeyboardWindowDelegate makes sure the keyboard-window does not get focus.
@@ skipping 79 matching lines @@
  private:
   aura::Window* container_;
   aura::Window* keyboard_;
 
   DISALLOW_COPY_AND_ASSIGN(KeyboardLayoutManager);
 };
 
 KeyboardController::KeyboardController(KeyboardControllerProxy* proxy)
     : proxy_(proxy),
       container_(NULL),
-      input_method_(NULL) {
+      input_method_(NULL),
+      keyboard_visible_(false),
+      weak_factory_(this) {
   CHECK(proxy);
   input_method_ = proxy_->GetInputMethod();
   input_method_->AddObserver(this);
 }
 
 KeyboardController::~KeyboardController() {
   if (container_)
     container_->RemoveObserver(this);
   if (input_method_)
     input_method_->RemoveObserver(this);
@@ skipping 27 matching lines @@
 void KeyboardController::OnWindowDestroying(aura::Window* window) {
   DCHECK_EQ(container_, window);
   container_ = NULL;
 }
 
 void KeyboardController::OnTextInputStateChanged(
     const ui::TextInputClient* client) {
   if (!container_)
     return;
 
-  bool was_showing = container_->IsVisible();
+  bool was_showing = keyboard_visible_;
   bool should_show = was_showing;
   if (!client || client->GetTextInputType() == ui::TEXT_INPUT_TYPE_NONE) {
     should_show = false;
   } else {
     if (container_->children().empty()) {
       aura::Window* keyboard = proxy_->GetKeyboardWindow();
       keyboard->Show();
       container_->AddChild(keyboard);
       container_->layout_manager()->OnWindowResized();
     }
     container_->parent()->StackChildAtTop(container_);
     should_show = true;
   }
 
   if (was_showing != should_show) {
-    gfx::Rect new_bounds(
-        should_show ? container_->children()[0]->bounds() : gfx::Rect());
+    if (should_show) {
+      keyboard_visible_ = true;
+      weak_factory_.InvalidateWeakPtrs();
+      if (container_->IsVisible())
+        return;
 
-    FOR_EACH_OBSERVER(
-        KeyboardControllerObserver,
-        observer_list_,
-        OnKeyboardBoundsChanging(new_bounds));
-
-    if (should_show)
+      FOR_EACH_OBSERVER(
+          KeyboardControllerObserver,
+          observer_list_,
+          OnKeyboardBoundsChanging(container_->children()[0]->bounds()));
       proxy_->ShowKeyboardContainer(container_);
-    else
-      proxy_->HideKeyboardContainer(container_);
+    } else {
+      keyboard_visible_ = false;
+      base::MessageLoop::current()->PostDelayedTask(
+          FROM_HERE,
+          base::Bind(&KeyboardController::HideKeyboard,
+                     weak_factory_.GetWeakPtr()),
+          base::TimeDelta::FromMilliseconds(kHideKeyboardDelayMs));
+    }
   }
-
   // TODO(bryeung): whenever the TextInputClient changes we need to notify the
   // keyboard (with the TextInputType) so that it can reset it's state (e.g.
   // abandon compositions in progress)
 }
 
 void KeyboardController::OnInputMethodDestroyed(
     const ui::InputMethod* input_method) {
   DCHECK_EQ(input_method_, input_method);
   input_method_ = NULL;
 }
 
+void KeyboardController::HideKeyboard() {
+  FOR_EACH_OBSERVER(KeyboardControllerObserver,
+                    observer_list_,
+                    OnKeyboardBoundsChanging(gfx::Rect()));
+  proxy_->HideKeyboardContainer(container_);
+}
+
+bool KeyboardController::WillHideKeyboard() const {
+  return weak_factory_.HasWeakPtrs();
+}
+
 }  // namespace keyboard