Do not show fallback keyboard when Android IME is active.

Chrome OS provides the fallback virtual keyboard for IMEs that provide
their own HTML-based virtual keyboard. It's not useful for ARC IMEs
because their UI is based on Android's View.
This CL disables the fallback virtual keyboard while an ARC IME is
active.

Bug: 845079, 890677
Test: unit_tests
Change-Id: I9a799cf049c886cdc25f7ae04a97d716e38338ea
Reviewed-on: https://chromium-review.googlesource.com/c/1253318
Commit-Queue: Yuichiro Hanada <yhanada@chromium.org>
Reviewed-by: Yusuke Sato <yusukes@chromium.org>
Reviewed-by: James Cook <jamescook@chromium.org>
Cr-Commit-Position: refs/heads/master@{#596133}

chrome/browser/chromeos/arc/input_method_manager/DEPS

+specific_include_rules = {
+  # TODO(mash): Fix this. https://crbug.com/890677
+  "arc_input_method_manager_service\.cc": [
+    "+ash/shell.h",
+  ],
+}

chrome/browser/chromeos/arc/input_method_manager/arc_input_method_manager_service.cc

@@ -7,6 +7,7 @@
 #include <algorithm>
 #include <utility>
 
+#include "ash/shell.h"
 #include "base/logging.h"
 #include "base/memory/singleton.h"
 #include "base/stl_util.h"
@@ -97,7 +98,17 @@ class ArcInputMethodManagerService::ArcProxyInputMethodObserver
   ~ArcProxyInputMethodObserver() override = default;
 
   // input_method::InputMethodEngineBase::Observer overrides:
-  void OnActivate(const std::string& engine_id) override {}
+  void OnActivate(const std::string& engine_id) override {
+    // ash::Shell is not created in the unit tests.
+    if (!ash::Shell::HasInstance())
+      return;
+    const bool was_enabled = keyboard::IsKeyboardEnabled();
+    // Disable fallback virtual keyboard while Android IME is activated.
+    keyboard::SetKeyboardShowOverride(
+        keyboard::KEYBOARD_SHOW_OVERRIDE_DISABLED);
+    if (was_enabled)
+      ash::Shell::Get()->DisableKeyboard();
+  }
   void OnFocus(
       const ui::IMEEngineHandlerInterface::InputContext& context) override {
     owner_->Focus(context.id);
@@ -108,7 +119,18 @@ class ArcInputMethodManagerService::ArcProxyInputMethodObserver
       const input_method::InputMethodEngineBase::KeyboardEvent& event,
       ui::IMEEngineHandlerInterface::KeyEventDoneCallback key_data) override {}
   void OnReset(const std::string& engine_id) override {}
-  void OnDeactivated(const std::string& engine_id) override {}
+  void OnDeactivated(const std::string& engine_id) override {
+    // ash::Shell is not created in the unit tests.
+    if (!ash::Shell::HasInstance())
+      return;
+    const bool was_enabled = keyboard::IsKeyboardEnabled();
+    // Stop overriding virtual keyboard availability.
+    keyboard::SetKeyboardShowOverride(keyboard::KEYBOARD_SHOW_OVERRIDE_NONE);
+    // If the device is still in tablet mode, virtual keyboard may be enabled.
+    const bool is_enabled = keyboard::IsKeyboardEnabled();
+    if (!was_enabled && is_enabled)
+      ash::Shell::Get()->EnableKeyboard();
+  }
   void OnCompositionBoundsChanged(
       const std::vector<gfx::Rect>& bounds) override {
     owner_->UpdateTextInputState();

chrome/browser/chromeos/arc/input_method_manager/arc_input_method_manager_service_unittest.cc

@@ -9,6 +9,7 @@
 #include <utility>
 #include <vector>
 
+#include "ash/test/ash_test_base.h"
 #include "base/macros.h"
 #include "base/memory/scoped_refptr.h"
 #include "base/stl_util.h"
@@ -31,6 +32,7 @@
 #include "ui/base/ime/mock_ime_input_context_handler.h"
 #include "ui/base/ime/mock_input_method.h"
 #include "ui/keyboard/keyboard_controller.h"
+#include "ui/keyboard/keyboard_util.h"
 
 namespace arc {
 namespace {
@@ -200,7 +202,9 @@ class TestInputMethodManagerBridge : public ArcInputMethodManagerBridge {
   DISALLOW_COPY_AND_ASSIGN(TestInputMethodManagerBridge);
 };
 
-class ArcInputMethodManagerServiceTest : public testing::Test {
+// TODO(crbug.com/890677): Stop inheriting ash::AshTestBase once ash::Shell
+// dependency is removed from ArcInputMethodManagerService.
+class ArcInputMethodManagerServiceTest : public ash::AshTestBase {
  protected:
   ArcInputMethodManagerServiceTest()
       : arc_service_manager_(std::make_unique<ArcServiceManager>()) {}
@@ -219,12 +223,13 @@ class ArcInputMethodManagerServiceTest : public testing::Test {
   }
 
   void SetUp() override {
+    ash::AshTestBase::SetUp();
+    SetRunningOutsideAsh();
     ui::IMEBridge::Initialize();
     input_method_manager_ = new TestInputMethodManager();
     chromeos::input_method::InputMethodManager::Initialize(
         input_method_manager_);
     tablet_mode_client_ = std::make_unique<TabletModeClient>();
-    keyboard_controller_ = std::make_unique<keyboard::KeyboardController>();
     profile_ = std::make_unique<TestingProfile>();
     service_ = ArcInputMethodManagerService::GetForBrowserContextForTesting(
         profile_.get());
@@ -237,18 +242,16 @@ class ArcInputMethodManagerServiceTest : public testing::Test {
     test_bridge_ = nullptr;
     service_->Shutdown();
     profile_.reset(nullptr);
-    keyboard_controller_.reset(nullptr);
     tablet_mode_client_.reset(nullptr);
     chromeos::input_method::InputMethodManager::Shutdown();
     ui::IMEBridge::Shutdown();
+    ash::AshTestBase::TearDown();
   }
 
  private:
-  content::TestBrowserThreadBundle thread_bundle_;
   std::unique_ptr<ArcServiceManager> arc_service_manager_;
   std::unique_ptr<TestingProfile> profile_;
   std::unique_ptr<TabletModeClient> tablet_mode_client_;
-  std::unique_ptr<keyboard::KeyboardController> keyboard_controller_;
   TestInputMethodManager* input_method_manager_ = nullptr;
   TestInputMethodManagerBridge* test_bridge_ = nullptr;  // Owned by |service_|
 
@@ -783,4 +786,59 @@ TEST_F(ArcInputMethodManagerServiceTest, IMEOperations) {
   ui::IMEBridge::Get()->SetInputContextHandler(nullptr);
 }
 
+TEST_F(ArcInputMethodManagerServiceTest, DisableFallbackVirtualKeyboard) {
+  namespace ceiu = chromeos::extension_ime_util;
+  using crx_file::id_util::GenerateId;
+
+  base::test::ScopedFeatureList feature;
+  feature.InitAndEnableFeature(kEnableInputMethodFeature);
+  ToggleTabletMode(true);
+
+  // Adding one ARC IME.
+  {
+    const std::string android_ime_id = "test.arc.ime";
+    const std::string display_name = "DisplayName";
+    const std::string settings_url = "url_to_settings";
+    mojom::ImeInfoPtr info = mojom::ImeInfo::New();
+    info->ime_id = android_ime_id;
+    info->display_name = display_name;
+    info->enabled = false;
+    info->settings_url = settings_url;
+
+    std::vector<mojom::ImeInfoPtr> info_array;
+    info_array.emplace_back(std::move(info));
+    service()->OnImeInfoChanged(std::move(info_array));
+  }
+  // The proxy IME engine should be added.
+  ASSERT_EQ(1u, imm()->state()->added_input_method_extensions_.size());
+  ui::IMEEngineHandlerInterface* engine_handler =
+      std::get<2>(imm()->state()->added_input_method_extensions_.at(0));
+  // Enable it
+  ui::IMEBridge::Get()->SetCurrentEngineHandler(engine_handler);
+
+  const std::string extension_ime_id =
+      ceiu::GetInputMethodID(GenerateId("test.extension.ime"), "us");
+  const std::string component_extension_ime_id =
+      ceiu::GetComponentInputMethodID(
+          GenerateId("test.component.extension.ime"), "us");
+
+  // Enable Chrome OS virtual keyboard
+  keyboard::SetTouchKeyboardEnabled(true);
+  keyboard::SetKeyboardShowOverride(keyboard::KEYBOARD_SHOW_OVERRIDE_NONE);
+  ASSERT_TRUE(keyboard::IsKeyboardEnabled());
+
+  // It's disabled when the ARC IME is activated.
+  ui::IMEBridge::Get()->SetCurrentEngineHandler(engine_handler);
+  engine_handler->Enable(
+      chromeos::extension_ime_util::GetComponentIDByInputMethodID(
+          std::get<1>(imm()->state()->added_input_method_extensions_.at(0))
+              .at(0)
+              .id()));
+  EXPECT_FALSE(keyboard::IsKeyboardEnabled());
+
+  // It's re-enabled when the ARC IME is deactivated.
+  engine_handler->Disable();
+  EXPECT_TRUE(keyboard::IsKeyboardEnabled());
+}
+
 }  // namespace arc