Add SetKeyboardLocked and bounds setters to ash.mojom.KeyboardController

This CL updates the remaining ChromeVirtualKeyboardDelegate calls to use
ChromeKeyboardControllerClient instead of direct calls to
keyboard::KeyboardController.

This also adds OnKeyboardEnableFlagsChanged to ensure that the enable
flags are cached accurately on the chrome side.

Bug: 876138
Change-Id: I3022fa78df7c589c22579b4b4e3b2a3279622f81
Reviewed-on: https://chromium-review.googlesource.com/c/1330894Reviewed-by: Darren Shen <shend@chromium.org>
Reviewed-by: Scott Violet <sky@chromium.org>
Reviewed-by: Tom Sepez <tsepez@chromium.org>
Commit-Queue: Steven Bennetts <stevenjb@chromium.org>
Cr-Commit-Position: refs/heads/master@{#608618}

ash/keyboard/ash_keyboard_controller.cc

@@ -164,6 +164,27 @@ void AshKeyboardController::SetContainerType(
                                          std::move(callback));
 }
 
+void AshKeyboardController::SetKeyboardLocked(bool locked) {
+  keyboard_controller_->set_keyboard_locked(locked);
+}
+
+void AshKeyboardController::SetOccludedBounds(
+    const std::vector<gfx::Rect>& bounds) {
+  // TODO(https://crbug.com/826617): Support occluded bounds with multiple
+  // rectangles.
+  keyboard_controller_->SetOccludedBounds(bounds.empty() ? gfx::Rect()
+                                                         : bounds[0]);
+}
+
+void AshKeyboardController::SetHitTestBounds(
+    const std::vector<gfx::Rect>& bounds) {
+  keyboard_controller_->SetHitTestBounds(bounds);
+}
+
+void AshKeyboardController::SetDraggableArea(const gfx::Rect& bounds) {
+  keyboard_controller_->SetDraggableArea(bounds);
+}
+
 void AshKeyboardController::OnSessionStateChanged(
     session_manager::SessionState state) {
   if (!keyboard_controller_->IsKeyboardEnableRequested())
@@ -248,6 +269,15 @@ void AshKeyboardController::OnKeyboardVisibleBoundsChanged(
   });
 }
 
+void AshKeyboardController::OnKeyboardEnableFlagsChanged(
+    std::set<keyboard::mojom::KeyboardEnableFlag>& keyboard_enable_flags) {
+  std::vector<keyboard::mojom::KeyboardEnableFlag> flags(
+      keyboard_enable_flags.begin(), keyboard_enable_flags.end());
+  observers_.ForAllPtrs([&flags](mojom::KeyboardControllerObserver* observer) {
+    observer->OnKeyboardEnableFlagsChanged(flags);
+  });
+}
+
 void AshKeyboardController::OnKeyboardEnabledChanged(bool is_enabled) {
   observers_.ForAllPtrs(
       [is_enabled](mojom::KeyboardControllerObserver* observer) {

ash/keyboard/ash_keyboard_controller.h

@@ -73,6 +73,10 @@ class ASH_EXPORT AshKeyboardController
   void SetContainerType(keyboard::mojom::ContainerType container_type,
                         const base::Optional<gfx::Rect>& target_bounds,
                         SetContainerTypeCallback callback) override;
+  void SetKeyboardLocked(bool locked) override;
+  void SetOccludedBounds(const std::vector<gfx::Rect>& bounds) override;
+  void SetHitTestBounds(const std::vector<gfx::Rect>& bounds) override;
+  void SetDraggableArea(const gfx::Rect& bounds) override;
   void AddObserver(
       mojom::KeyboardControllerObserverAssociatedPtrInfo observer) override;
 
@@ -105,6 +109,9 @@ class ASH_EXPORT AshKeyboardController
   void OnKeyboardConfigChanged() override;
   void OnKeyboardVisibilityStateChanged(bool is_visible) override;
   void OnKeyboardVisibleBoundsChanged(const gfx::Rect& bounds) override;
+  void OnKeyboardEnableFlagsChanged(
+      std::set<keyboard::mojom::KeyboardEnableFlag>& keyboard_enable_flags)
+      override;
   void OnKeyboardEnabledChanged(bool is_enabled) override;
 
   SessionController* session_controller_;  // unowned

ash/public/interfaces/keyboard_controller.mojom

@@ -18,6 +18,9 @@ enum HideReason {
 };
 
 interface KeyboardControllerObserver {
+  // Called when a keyboard enable flag changes.
+  OnKeyboardEnableFlagsChanged(array<keyboard.mojom.KeyboardEnableFlag> flags);
+
   // Called when the keyboard is enabled or disabled. If ReloadKeyboard() is
   // called or other code enables the keyboard while already enabled, this will
   // be called twice, once when the keyboard is disabled and again when it is
@@ -53,7 +56,7 @@ interface KeyboardController {
   // changes, enables or disables the keyboard to match the new state.
   ClearEnableFlag(keyboard.mojom.KeyboardEnableFlag flag);
 
-  // Gets the current set of keyboard enabled flags.
+  // Gets the current set of keyboard enable flags.
   GetEnableFlags() => (array<keyboard.mojom.KeyboardEnableFlag> flags);
 
   // Reloads the virtual keyboard if it is enabled and the URL has changed, e.g.
@@ -80,6 +83,19 @@ interface KeyboardController {
   SetContainerType(keyboard.mojom.ContainerType container_type,
                    gfx.mojom.Rect? target_bounds) => (bool result);
 
+  // If |locked| is true, the keyboard remains visible even when no window has
+  // input focus.
+  SetKeyboardLocked(bool locked);
+
+  // Sets the regions of the keyboard window that occlude whatever is behind it.
+  SetOccludedBounds(array<gfx.mojom.Rect> bounds);
+
+  // Sets the regions of the keyboard window where events should be handled.
+  SetHitTestBounds(array<gfx.mojom.Rect> bounds);
+
+  // Sets the region of the keyboard window that can be used as a drag handle.
+  SetDraggableArea(gfx.mojom.Rect bounds);
+
   // Adds a KeyboardControllerObserver.
   AddObserver(associated KeyboardControllerObserver observer);
 };

chrome/browser/extensions/api/virtual_keyboard_private/DEPS

@@ -2,12 +2,3 @@ include_rules = [
   "+media/audio"
   "+services/audio/public/cpp"
 ]
-
-specific_include_rules = {
-  # TODO(mash): Fix. https://crbug.com/646565
-  "chrome_virtual_keyboard_delegate\.cc": [
-    "+ash/shell.h",
-    # TODO(stevenjb): Fix this for Mash. https://crbug.com/876138.
-    "+ui/keyboard",
-  ]
-}

chrome/browser/extensions/api/virtual_keyboard_private/chrome_virtual_keyboard_delegate.cc

@@ -8,7 +8,6 @@
 #include <string>
 #include <utility>
 
-#include "ash/shell.h"
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/feature_list.h"
@@ -43,8 +42,6 @@
 #include "ui/events/keycodes/dom/dom_key.h"
 #include "ui/events/keycodes/dom/keycode_converter.h"
 #include "ui/events/keycodes/keyboard_code_conversion.h"
-#include "ui/keyboard/keyboard_controller.h"
-#include "ui/keyboard/keyboard_util.h"
 #include "ui/keyboard/public/keyboard_controller_types.mojom.h"
 #include "ui/keyboard/public/keyboard_switches.h"
 
@@ -187,13 +184,13 @@ void ChromeVirtualKeyboardDelegate::OnKeyboardConfigChanged() {
 
 bool ChromeVirtualKeyboardDelegate::HideKeyboard() {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
-  auto* controller = keyboard::KeyboardController::Get();
-  if (!controller->IsEnabled())
+  auto* keyboard_client = ChromeKeyboardControllerClient::Get();
+  if (!keyboard_client->is_keyboard_enabled())
     return false;
 
   // Pass HIDE_REASON_MANUAL since calls to HideKeyboard as part of this API
   // would be user generated.
-  controller->HideKeyboardByUser();
+  keyboard_client->HideKeyboard(ash::mojom::HideReason::kUser);
   return true;
 }
 
@@ -232,11 +229,11 @@ void ChromeVirtualKeyboardDelegate::SetHotrodKeyboard(bool enable) {
 
 bool ChromeVirtualKeyboardDelegate::LockKeyboard(bool state) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
-  auto* controller = keyboard::KeyboardController::Get();
-  if (!controller->IsEnabled())
+  auto* keyboard_client = ChromeKeyboardControllerClient::Get();
+  if (!keyboard_client->is_keyboard_enabled())
     return false;
 
-  controller->set_keyboard_locked(state);
+  keyboard_client->SetKeyboardLocked(state);
   return true;
 }
 
@@ -254,9 +251,9 @@ bool ChromeVirtualKeyboardDelegate::SendKeyEvent(const std::string& type,
 
 bool ChromeVirtualKeyboardDelegate::ShowLanguageSettings() {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
-  auto* controller = keyboard::KeyboardController::Get();
-  if (controller->IsEnabled())
-    controller->DismissVirtualKeyboard();
+  auto* keyboard_client = ChromeKeyboardControllerClient::Get();
+  if (keyboard_client->is_keyboard_enabled())
+    keyboard_client->HideKeyboard(ash::mojom::HideReason::kUser);
 
   base::RecordAction(base::UserMetricsAction("OpenLanguageOptionsDialog"));
   chrome::ShowSettingsSubPageForProfile(ProfileManager::GetActiveUserProfile(),
@@ -280,37 +277,35 @@ bool ChromeVirtualKeyboardDelegate::SetVirtualKeyboardMode(
 
 bool ChromeVirtualKeyboardDelegate::SetOccludedBounds(
     const std::vector<gfx::Rect>& bounds) {
-  keyboard::KeyboardController* controller =
-      keyboard::KeyboardController::Get();
-  if (!controller->IsEnabled())
+  auto* keyboard_client = ChromeKeyboardControllerClient::Get();
+  if (!keyboard_client->is_keyboard_enabled())
     return false;
 
-  // TODO(https://crbug.com/826617): Support occluded bounds with multiple
-  // rectangles.
-  controller->SetOccludedBounds(bounds.empty() ? gfx::Rect() : bounds[0]);
+  keyboard_client->SetOccludedBounds(bounds);
   return true;
 }
 
 bool ChromeVirtualKeyboardDelegate::SetHitTestBounds(
     const std::vector<gfx::Rect>& bounds) {
-  keyboard::KeyboardController* controller =
-      keyboard::KeyboardController::Get();
-  if (!controller->IsEnabled())
+  auto* keyboard_client = ChromeKeyboardControllerClient::Get();
+  if (!keyboard_client->is_keyboard_enabled())
     return false;
 
-  controller->SetHitTestBounds(bounds);
+  keyboard_client->SetHitTestBounds(bounds);
   return true;
 }
 
 bool ChromeVirtualKeyboardDelegate::SetDraggableArea(
     const api::virtual_keyboard_private::Bounds& rect) {
-  auto* controller = keyboard::KeyboardController::Get();
+  auto* keyboard_client = ChromeKeyboardControllerClient::Get();
   // Since controller will be destroyed when system switch from VK to
   // physical keyboard, return true to avoid unneccessary exception.
-  if (!controller->IsEnabled())
+  if (!keyboard_client->is_keyboard_enabled())
     return true;
-  return controller->SetDraggableArea(
+
+  keyboard_client->SetDraggableArea(
       gfx::Rect(rect.left, rect.top, rect.width, rect.height));
+  return true;
 }
 
 bool ChromeVirtualKeyboardDelegate::SetRequestedKeyboardState(int state_enum) {
@@ -345,12 +340,17 @@ void ChromeVirtualKeyboardDelegate::OnHasInputDevices(
     OnKeyboardSettingsCallback on_settings_callback,
     bool has_audio_input_devices) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
+  auto* keyboard_client = ChromeKeyboardControllerClient::Get();
+
   std::unique_ptr<base::DictionaryValue> results(new base::DictionaryValue());
   results->SetString("layout", GetKeyboardLayout());
 
   // TODO(bshe): Consolidate a11y, hotrod and normal mode into a mode enum. See
   // crbug.com/529474.
-  results->SetBoolean("a11ymode", keyboard::GetAccessibilityKeyboardEnabled());
+  results->SetBoolean(
+      "a11ymode",
+      keyboard_client->IsEnableFlagSet(
+          keyboard::mojom::KeyboardEnableFlag::kAccessibilityEnabled));
   results->SetBoolean("hotrodmode", g_hotrod_keyboard_enabled);
   std::unique_ptr<base::ListValue> features(new base::ListValue());
 
@@ -388,7 +388,7 @@ void ChromeVirtualKeyboardDelegate::OnHasInputDevices(
       "imeservice", base::FeatureList::IsEnabled(
                         chromeos::features::kImeServiceConnectable)));
 
-  auto config = ChromeKeyboardControllerClient::Get()->GetKeyboardConfig();
+  keyboard::mojom::KeyboardConfig config = keyboard_client->GetKeyboardConfig();
   // TODO(oka): Change this to use config.voice_input.
   features->AppendString(GenerateFeatureFlag(
       "voiceinput", has_audio_input_devices && config.voice_input &&

chrome/browser/ui/ash/chrome_keyboard_controller_client.cc

@@ -72,9 +72,9 @@ ChromeKeyboardControllerClient::ChromeKeyboardControllerClient(
                      weak_ptr_factory_.GetWeakPtr()));
 
   // Request the initial set of enable flags.
-  keyboard_controller_ptr_->GetEnableFlags(
-      base::BindOnce(&ChromeKeyboardControllerClient::OnGetEnableFlags,
-                     weak_ptr_factory_.GetWeakPtr()));
+  keyboard_controller_ptr_->GetEnableFlags(base::BindOnce(
+      &ChromeKeyboardControllerClient::OnKeyboardEnableFlagsChanged,
+      weak_ptr_factory_.GetWeakPtr()));
 
   // Request the initial visible state.
   keyboard_controller_ptr_->IsKeyboardVisible(base::BindOnce(
@@ -125,17 +125,11 @@ void ChromeKeyboardControllerClient::GetKeyboardEnabled(
 void ChromeKeyboardControllerClient::SetEnableFlag(
     const keyboard::mojom::KeyboardEnableFlag& flag) {
   keyboard_controller_ptr_->SetEnableFlag(flag);
-  keyboard_controller_ptr_->GetEnableFlags(
-      base::BindOnce(&ChromeKeyboardControllerClient::OnGetEnableFlags,
-                     weak_ptr_factory_.GetWeakPtr()));
 }
 
 void ChromeKeyboardControllerClient::ClearEnableFlag(
     const keyboard::mojom::KeyboardEnableFlag& flag) {
   keyboard_controller_ptr_->ClearEnableFlag(flag);
-  keyboard_controller_ptr_->GetEnableFlags(
-      base::BindOnce(&ChromeKeyboardControllerClient::OnGetEnableFlags,
-                     weak_ptr_factory_.GetWeakPtr()));
 }
 
 bool ChromeKeyboardControllerClient::IsEnableFlagSet(
@@ -168,6 +162,24 @@ void ChromeKeyboardControllerClient::SetContainerType(
                                              std::move(callback));
 }
 
+void ChromeKeyboardControllerClient::SetKeyboardLocked(bool locked) {
+  keyboard_controller_ptr_->SetKeyboardLocked(locked);
+}
+
+void ChromeKeyboardControllerClient::SetOccludedBounds(
+    const std::vector<gfx::Rect>& bounds) {
+  keyboard_controller_ptr_->SetOccludedBounds(bounds);
+}
+
+void ChromeKeyboardControllerClient::SetHitTestBounds(
+    const std::vector<gfx::Rect>& bounds) {
+  keyboard_controller_ptr_->SetHitTestBounds(bounds);
+}
+
+void ChromeKeyboardControllerClient::SetDraggableArea(const gfx::Rect& bounds) {
+  keyboard_controller_ptr_->SetDraggableArea(bounds);
+}
+
 bool ChromeKeyboardControllerClient::IsKeyboardOverscrollEnabled() {
   DCHECK(cached_keyboard_config_);
   if (cached_keyboard_config_->overscroll_behavior !=
@@ -214,6 +226,12 @@ void ChromeKeyboardControllerClient::FlushForTesting() {
   keyboard_controller_ptr_.FlushForTesting();
 }
 
+void ChromeKeyboardControllerClient::OnKeyboardEnableFlagsChanged(
+    const std::vector<keyboard::mojom::KeyboardEnableFlag>& flags) {
+  keyboard_enable_flags_ =
+      std::set<keyboard::mojom::KeyboardEnableFlag>(flags.begin(), flags.end());
+}
+
 void ChromeKeyboardControllerClient::OnKeyboardEnabledChanged(bool enabled) {
   bool was_enabled = is_keyboard_enabled_;
   is_keyboard_enabled_ = enabled;
@@ -281,12 +299,6 @@ void ChromeKeyboardControllerClient::OnKeyboardVisibleBoundsChanged(
   router->BroadcastEvent(std::move(event));
 }
 
-void ChromeKeyboardControllerClient::OnGetEnableFlags(
-    const std::vector<keyboard::mojom::KeyboardEnableFlag>& flags) {
-  keyboard_enable_flags_ =
-      std::set<keyboard::mojom::KeyboardEnableFlag>(flags.begin(), flags.end());
-}
-
 Profile* ChromeKeyboardControllerClient::GetProfile() {
   if (profile_for_test_)
     return profile_for_test_;

chrome/browser/ui/ash/chrome_keyboard_controller_client.h

@@ -79,6 +79,10 @@ class ChromeKeyboardControllerClient
   void SetContainerType(keyboard::mojom::ContainerType container_type,
                         const base::Optional<gfx::Rect>& target_bounds,
                         base::OnceCallback<void(bool)> callback);
+  void SetKeyboardLocked(bool locked);
+  void SetOccludedBounds(const std::vector<gfx::Rect>& bounds);
+  void SetHitTestBounds(const std::vector<gfx::Rect>& bounds);
+  void SetDraggableArea(const gfx::Rect& bounds);
 
   // Returns true if overscroll is enabled by the config or command line.
   bool IsKeyboardOverscrollEnabled();
@@ -101,15 +105,14 @@ class ChromeKeyboardControllerClient
 
  private:
   // keyboard::mojom::KeyboardControllerObserver:
+  void OnKeyboardEnableFlagsChanged(
+      const std::vector<keyboard::mojom::KeyboardEnableFlag>& flags) override;
   void OnKeyboardEnabledChanged(bool enabled) override;
   void OnKeyboardConfigChanged(
       keyboard::mojom::KeyboardConfigPtr config) override;
   void OnKeyboardVisibilityChanged(bool visible) override;
   void OnKeyboardVisibleBoundsChanged(const gfx::Rect& bounds) override;
 
-  void OnGetEnableFlags(
-      const std::vector<keyboard::mojom::KeyboardEnableFlag>& flags);
-
   // Returns either the test profile or the active user profile.
   Profile* GetProfile();
 

chrome/browser/ui/ash/chrome_keyboard_controller_client_test_helper.cc

@@ -59,6 +59,10 @@ class ChromeKeyboardControllerClientTestHelper::FakeKeyboardController
                         SetContainerTypeCallback callback) override {
     std::move(callback).Run(true);
   }
+  void SetKeyboardLocked(bool locked) override {}
+  void SetOccludedBounds(const std::vector<gfx::Rect>& bounds) override {}
+  void SetHitTestBounds(const std::vector<gfx::Rect>& bounds) override {}
+  void SetDraggableArea(const gfx::Rect& bounds) override {}
   void AddObserver(ash::mojom::KeyboardControllerObserverAssociatedPtrInfo
                        observer) override {}
 

ui/keyboard/container_behavior.h

@@ -115,7 +115,7 @@ class KEYBOARD_EXPORT ContainerBehavior {
   virtual bool OccludedBoundsAffectWorkspaceLayout() const = 0;
 
   // Sets floating keyboard drggable rect.
-  virtual bool SetDraggableArea(const gfx::Rect& rect) = 0;
+  virtual void SetDraggableArea(const gfx::Rect& rect) = 0;
 
  protected:
   Delegate* delegate_;

ui/keyboard/container_floating_behavior.cc

@@ -309,9 +309,8 @@ bool ContainerFloatingBehavior::OccludedBoundsAffectWorkspaceLayout() const {
   return false;
 }
 
-bool ContainerFloatingBehavior::SetDraggableArea(const gfx::Rect& rect) {
+void ContainerFloatingBehavior::SetDraggableArea(const gfx::Rect& rect) {
   draggable_area_ = rect;
-  return true;
 }
 
 }  //  namespace keyboard

ui/keyboard/container_floating_behavior.h

@@ -48,7 +48,7 @@ class KEYBOARD_EXPORT ContainerFloatingBehavior : public ContainerBehavior {
   gfx::Rect GetOccludedBounds(
       const gfx::Rect& visual_bounds_in_screen) const override;
   bool OccludedBoundsAffectWorkspaceLayout() const override;
-  bool SetDraggableArea(const gfx::Rect& rect) override;
+  void SetDraggableArea(const gfx::Rect& rect) override;
 
   // Calculate the position of the keyboard for when it is being shown.
   gfx::Point GetPositionForShowingKeyboard(

ui/keyboard/container_full_width_behavior.cc

@@ -126,11 +126,8 @@ bool ContainerFullWidthBehavior::OccludedBoundsAffectWorkspaceLayout() const {
   return delegate_->IsKeyboardLocked();
 }
 
-bool ContainerFullWidthBehavior::SetDraggableArea(const gfx::Rect& rect) {
+void ContainerFullWidthBehavior::SetDraggableArea(const gfx::Rect& rect) {
   // Allow extension to call this function but does nothing here.
-  // To avoid unnecessary exception when VK calls this function to
-  // clear draggable area in full width mode.
-  return true;
 }
 
 }  //  namespace keyboard

ui/keyboard/container_full_width_behavior.h

@@ -45,7 +45,7 @@ class KEYBOARD_EXPORT ContainerFullWidthBehavior : public ContainerBehavior {
   gfx::Rect GetOccludedBounds(
       const gfx::Rect& visual_bounds_in_screen) const override;
   bool OccludedBoundsAffectWorkspaceLayout() const override;
-  bool SetDraggableArea(const gfx::Rect& rect) override;
+  void SetDraggableArea(const gfx::Rect& rect) override;
 
  private:
   gfx::Rect occluded_bounds_in_window_;

ui/keyboard/keyboard_controller.cc

@@ -398,10 +398,14 @@ void KeyboardController::SetEnableFlag(mojom::KeyboardEnableFlag flag) {
     default:
       break;
   }
+  for (KeyboardControllerObserver& observer : observer_list_)
+    observer.OnKeyboardEnableFlagsChanged(keyboard_enable_flags_);
 }
 
 void KeyboardController::ClearEnableFlag(mojom::KeyboardEnableFlag flag) {
   keyboard_enable_flags_.erase(flag);
+  for (KeyboardControllerObserver& observer : observer_list_)
+    observer.OnKeyboardEnableFlagsChanged(keyboard_enable_flags_);
 }
 
 bool KeyboardController::IsEnableFlagSet(mojom::KeyboardEnableFlag flag) const {
@@ -1033,8 +1037,8 @@ void KeyboardController::RecordUkmKeyboardShown() {
       text_input_client->GetTextInputType());
 }
 
-bool KeyboardController::SetDraggableArea(const gfx::Rect& rect) {
-  return container_behavior_->SetDraggableArea(rect);
+void KeyboardController::SetDraggableArea(const gfx::Rect& rect) {
+  container_behavior_->SetDraggableArea(rect);
 }
 
 // InputMethodKeyboardController overrides:

ui/keyboard/keyboard_controller.h

@@ -238,7 +238,7 @@ class KEYBOARD_EXPORT KeyboardController
                         base::OnceCallback<void(bool)> callback);
 
   // Sets floating keyboard draggable rect.
-  bool SetDraggableArea(const gfx::Rect& rect);
+  void SetDraggableArea(const gfx::Rect& rect);
 
   // InputMethodKeyboardController overrides:
   bool DisplayVirtualKeyboard() override;
@@ -252,6 +252,10 @@ class KEYBOARD_EXPORT KeyboardController
   bool keyboard_locked() const { return keyboard_locked_; }
   void set_keyboard_locked(bool lock) { keyboard_locked_ = lock; }
 
+  void set_container_behavior_for_test(
+      std::unique_ptr<ContainerBehavior> container_behavior) {
+    container_behavior_ = std::move(container_behavior);
+  }
   KeyboardControllerState GetStateForTest() const { return state_; }
   ui::InputMethod* GetInputMethodForTest();
   void EnsureCaretInWorkAreaForTest(const gfx::Rect& occluded_bounds);

ui/keyboard/keyboard_controller_observer.h

@@ -67,6 +67,10 @@ class KEYBOARD_EXPORT KeyboardControllerObserver {
   virtual void OnKeyboardAppearanceChanged(
       const KeyboardStateDescriptor& state) {}
 
+  // Called when an enable flag affecting the requested enabled state changes.
+  virtual void OnKeyboardEnableFlagsChanged(
+      std::set<mojom::KeyboardEnableFlag>& keyboard_enable_flags) {}
+
   // Called when the keyboard is enabled or disabled. NOTE: This is called
   // when Enabled() or Disabled() is called, not when the requested enabled
   // state (IsEnableRequested) changes.