keyboard: Fix hit-testing code to not create the keyboard window.

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 66 matching lines @@
     }
   }
 
   aura::Window* root_;
   DISALLOW_COPY_AND_ASSIGN(TestFocusController);
 };
 
 class TestKeyboardControllerProxy : public KeyboardControllerProxy {
  public:
   TestKeyboardControllerProxy()
-      : window_(new aura::Window(&delegate_)),
-        input_method_(ui::CreateInputMethod(NULL,
-                                            gfx::kNullAcceleratedWidget)) {
-    window_->Init(aura::WINDOW_LAYER_NOT_DRAWN);
-    window_->set_owned_by_parent(false);
-  }
+      : input_method_(
+            ui::CreateInputMethod(NULL, gfx::kNullAcceleratedWidget)) {}
 
   virtual ~TestKeyboardControllerProxy() {
     // Destroy the window before the delegate.
     window_.reset();
   }
 
   // Overridden from KeyboardControllerProxy:
-  virtual bool HasKeyboardWindow() const OVERRIDE { return true; }
-  virtual aura::Window* GetKeyboardWindow() OVERRIDE { return window_.get(); }
+  virtual bool HasKeyboardWindow() const OVERRIDE { return window_; }
+  virtual aura::Window* GetKeyboardWindow() OVERRIDE {
+    if (!window_) {
+      window_.reset(new aura::Window(&delegate_));
+      window_->Init(aura::WINDOW_LAYER_NOT_DRAWN);
+      window_->set_owned_by_parent(false);
+    }
+    return window_.get();
+  }
   virtual content::BrowserContext* GetBrowserContext() OVERRIDE { return NULL; }
   virtual ui::InputMethod* GetInputMethod() OVERRIDE {
     return input_method_.get();
   }
   virtual void RequestAudioInput(content::WebContents* web_contents,
       const content::MediaStreamRequest& request,
       const content::MediaResponseCallback& callback) OVERRIDE { return; }
   virtual void LoadSystemKeyboard() OVERRIDE {};
   virtual void ReloadKeyboardIfNeeded() OVERRIDE {};
 
@@ skipping 226 matching lines @@
   ui::MouseEvent mouse1(ui::ET_MOUSE_MOVED, location, location, ui::EF_NONE,
                         ui::EF_NONE);
   EXPECT_EQ(keyboard_window, targeter->FindTargetForEvent(root, &mouse1));
 
   location.set_y(keyboard_window->bounds().y() - 5);
   ui::MouseEvent mouse2(ui::ET_MOUSE_MOVED, location, location, ui::EF_NONE,
                         ui::EF_NONE);
   EXPECT_EQ(window.get(), targeter->FindTargetForEvent(root, &mouse2));
 }
 
+TEST_F(KeyboardControllerTest, KeyboardWindowCreation) {
+  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());
+  window->Show();
+  window->Focus();
+
+  aura::Window* keyboard_container(controller()->GetContainerWindow());
+  keyboard_container->SetBounds(root_bounds);
+
+  root_window()->AddChild(keyboard_container);
+  keyboard_container->Show();
+
+  EXPECT_FALSE(proxy()->HasKeyboardWindow());
+
+  ui::EventTarget* root = root_window();
+  ui::EventTargeter* targeter = root->GetEventTargeter();
+  gfx::Point location(root_window()->bounds().width() / 2,
+                      root_window()->bounds().height() - 10);
+  ui::MouseEvent mouse(
+      ui::ET_MOUSE_MOVED, location, location, ui::EF_NONE, ui::EF_NONE);
+  EXPECT_EQ(window.get(), targeter->FindTargetForEvent(root, &mouse));
+  EXPECT_FALSE(proxy()->HasKeyboardWindow());
+
+  EXPECT_EQ(
+      controller()->GetContainerWindow(),
+      controller()->GetContainerWindow()->GetEventHandlerForPoint(location));
+  EXPECT_FALSE(proxy()->HasKeyboardWindow());
+}
+
 TEST_F(KeyboardControllerTest, VisibilityChangeWithTextInputTypeChange) {
   const gfx::Rect& root_bounds = root_window()->bounds();
 
   ui::DummyTextInputClient input_client_0(ui::TEXT_INPUT_TYPE_TEXT);
   ui::DummyTextInputClient input_client_1(ui::TEXT_INPUT_TYPE_TEXT);
   ui::DummyTextInputClient input_client_2(ui::TEXT_INPUT_TYPE_TEXT);
   ui::DummyTextInputClient no_input_client_0(ui::TEXT_INPUT_TYPE_NONE);
   ui::DummyTextInputClient no_input_client_1(ui::TEXT_INPUT_TYPE_NONE);
 
   aura::Window* keyboard_container(controller()->GetContainerWindow());
@@ skipping 206 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