Add virtualKeyboardPrivate.onKeyboardClosed API.

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 <memory>
 
 #include "base/bind.h"
 #include "base/command_line.h"
@@ skipping 153 matching lines @@
   base::RunLoop* const run_loop_;
 
   DISALLOW_COPY_AND_ASSIGN(KeyboardContainerObserver);
 };
 
 }  // namespace
 
 class KeyboardControllerTest : public testing::Test,
                                public KeyboardControllerObserver {
  public:
-  KeyboardControllerTest() : number_of_calls_(0), ui_(nullptr) {}
+  KeyboardControllerTest()
+      : number_of_calls_(0), ui_(nullptr), keyboard_closed_(false) {}
   ~KeyboardControllerTest() override {}
 
   void SetUp() override {
     // The ContextFactory must exist before any Compositors are created.
     bool enable_pixel_output = false;
     ui::ContextFactory* context_factory =
         ui::InitializeContextFactoryForTests(enable_pixel_output);
 
     ui::SetUpInputMethodFactoryForTesting();
     aura_test_helper_.reset(new aura::test::AuraTestHelper(&message_loop_));
     aura_test_helper_->SetUp(context_factory);
     new wm::DefaultActivationClient(aura_test_helper_->root_window());
     focus_controller_.reset(new TestFocusController(root_window()));
     ui_ = new TestKeyboardUI(aura_test_helper_->host()->GetInputMethod());
     controller_.reset(new KeyboardController(ui_));
     controller()->AddObserver(this);
   }
 
   void TearDown() override {
-    controller()->RemoveObserver(this);
+    if (controller())
+      controller()->RemoveObserver(this);
     controller_.reset();
     focus_controller_.reset();
     aura_test_helper_->TearDown();
     ui::TerminateContextFactoryForTests();
   }
 
   aura::Window* root_window() { return aura_test_helper_->root_window(); }
   KeyboardUI* ui() { return ui_; }
   KeyboardController* controller() { return controller_.get(); }
 
   void ShowKeyboard() {
     test_text_input_client_.reset(
         new ui::DummyTextInputClient(ui::TEXT_INPUT_TYPE_TEXT));
     SetFocus(test_text_input_client_.get());
   }
 
   void MockRotateScreen() {
     const gfx::Rect root_bounds = root_window()->bounds();
     root_window()->SetBounds(
         gfx::Rect(0, 0, root_bounds.height(), root_bounds.width()));
   }
 
  protected:
   // KeyboardControllerObserver overrides
   void OnKeyboardBoundsChanging(const gfx::Rect& new_bounds) override {
     notified_bounds_ = new_bounds;
     number_of_calls_++;
   }
+  void OnKeyboardClosed() override { keyboard_closed_ = true; }
 
   int number_of_calls() const { return number_of_calls_; }
 
   const gfx::Rect& notified_bounds() { return notified_bounds_; }
 
+  bool IsKeyboardClosed() { return keyboard_closed_; }
+
   void SetFocus(ui::TextInputClient* client) {
     ui::InputMethod* input_method = ui()->GetInputMethod();
     input_method->SetFocusedTextInputClient(client);
     if (client && client->GetTextInputType() != ui::TEXT_INPUT_TYPE_NONE) {
       input_method->ShowImeIfNeeded();
       if (ui_->GetKeyboardWindow()->bounds().height() == 0) {
         // Set initial bounds for test keyboard window.
         ui_->GetKeyboardWindow()->SetBounds(
             FullWidthKeyboardBoundsFromRootBounds(
                 root_window()->bounds(), kDefaultVirtualKeyboardHeight));
       }
     }
   }
 
   bool WillHideKeyboard() {
     return controller_->WillHideKeyboard();
   }
 
   bool ShouldEnableInsets(aura::Window* window) {
     aura::Window* keyboard_window = ui_->GetKeyboardWindow();
     return (keyboard_window->GetRootWindow() == window->GetRootWindow() &&
             keyboard::IsKeyboardOverscrollEnabled() &&
             keyboard_window->IsVisible() &&
             controller_->keyboard_visible());
   }
 
+  void ResetController() { controller_.reset(); }
+
   base::MessageLoopForUI message_loop_;
   std::unique_ptr<aura::test::AuraTestHelper> aura_test_helper_;
   std::unique_ptr<TestFocusController> focus_controller_;
 
  private:
   int number_of_calls_;
   gfx::Rect notified_bounds_;
   KeyboardUI* ui_;
   std::unique_ptr<KeyboardController> controller_;
   std::unique_ptr<ui::TextInputClient> test_text_input_client_;
+  bool keyboard_closed_;
   DISALLOW_COPY_AND_ASSIGN(KeyboardControllerTest);
 };
 
 TEST_F(KeyboardControllerTest, KeyboardSize) {
   aura::Window* container(controller()->GetContainerWindow());
   aura::Window* keyboard(ui()->GetKeyboardWindow());
   gfx::Rect screen_bounds = root_window()->bounds();
   root_window()->AddChild(container);
   container->AddChild(keyboard);
   const gfx::Rect& initial_bounds = container->bounds();
@@ skipping 246 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.
   run_loop.Run();
   EXPECT_FALSE(keyboard_container->IsVisible());
   keyboard::SetAccessibilityKeyboardEnabled(false);
 }
 
+// Tests that deactivates keyboard will get closed event.
+TEST_F(KeyboardControllerTest, CloseKeyboard) {
+  keyboard::SetAccessibilityKeyboardEnabled(true);
+  aura::Window* keyboard_container(controller()->GetContainerWindow());
+  root_window()->AddChild(keyboard_container);
+  keyboard_container->Show();
+
+  ShowKeyboard();
+  EXPECT_TRUE(keyboard_container->IsVisible());
+  EXPECT_FALSE(IsKeyboardClosed());
+
+  root_window()->RemoveChild(keyboard_container);
+  ResetController();
+  EXPECT_TRUE(IsKeyboardClosed());
+}
+
 class KeyboardControllerAnimationTest : public KeyboardControllerTest {
  public:
   KeyboardControllerAnimationTest() {}
   ~KeyboardControllerAnimationTest() override {}
 
   void SetUp() override {
     // We cannot short-circuit animations for this test.
     ui::ScopedAnimationDurationScaleMode test_duration_mode(
         ui::ScopedAnimationDurationScaleMode::NON_ZERO_DURATION);
 
@@ skipping 118 matching lines @@
   gfx::Rect new_bounds(0, 0, 1280, 800);
   ASSERT_NE(new_bounds, root_window()->bounds());
   EXPECT_EQ(1, number_of_calls());
   root_window()->SetBounds(new_bounds);
   EXPECT_EQ(2, number_of_calls());
   MockRotateScreen();
   EXPECT_EQ(3, number_of_calls());
 }
 
 }  // namespace keyboard