ash/keyboard/ui/keyboard_ui_controller.cc

// Copyright 2013 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#include "ash/keyboard/ui/keyboard_ui_controller.h"

#include <set>

#include "ash/keyboard/ui/container_floating_behavior.h"
#include "ash/keyboard/ui/container_full_width_behavior.h"
#include "ash/keyboard/ui/display_util.h"
#include "ash/keyboard/ui/keyboard_layout_manager.h"
#include "ash/keyboard/ui/keyboard_ui.h"
#include "ash/keyboard/ui/keyboard_ui_factory.h"
#include "ash/keyboard/ui/keyboard_util.h"
#include "ash/keyboard/ui/notification_manager.h"
#include "ash/keyboard/ui/queued_container_type.h"
#include "ash/keyboard/ui/queued_display_change.h"
#include "ash/keyboard/ui/shaped_window_targeter.h"
#include "ash/public/cpp/keyboard/keyboard_controller_observer.h"
#include "ash/public/cpp/keyboard/keyboard_switches.h"
#include "base/command_line.h"
#include "base/containers/contains.h"
#include "base/functional/bind.h"
#include "base/memory/raw_ptr.h"
#include "base/metrics/histogram_functions.h"
#include "base/metrics/histogram_macros.h"
#include "base/task/single_thread_task_runner.h"
#include "base/time/time.h"
#include "base/trace_event/trace_event.h"
#include "ui/aura/client/aura_constants.h"
#include "ui/aura/client/screen_position_client.h"
#include "ui/aura/env.h"
#include "ui/aura/window.h"
#include "ui/aura/window_delegate.h"
#include "ui/aura/window_observer.h"
#include "ui/base/cursor/cursor.h"
#include "ui/base/hit_test.h"
#include "ui/base/ime/text_input_client.h"
#include "ui/base/ime/text_input_flags.h"
#include "ui/base/ime/virtual_keyboard_controller_observer.h"
#include "ui/compositor/layer.h"
#include "ui/compositor/layer_animation_observer.h"
#include "ui/compositor/scoped_layer_animation_settings.h"
#include "ui/display/types/display_constants.h"
#include "ui/events/base_event_utils.h"
#include "ui/events/gestures/gesture_recognizer.h"
#include "ui/gfx/geometry/rect.h"
#include "ui/gfx/geometry/vector2d.h"
#include "ui/wm/core/coordinate_conversion.h"
#include "ui/wm/core/window_animations.h"

namespace keyboard {

namespace {

// Owned by ash::Shell.
KeyboardUIController* g_keyboard_controller = nullptr;

// How long the keyboard stays in WILL_HIDE state before moving to HIDDEN.
constexpr base::TimeDelta kHideKeyboardDelay = base::Milliseconds(100);

// Reports an error histogram if the keyboard state is lingering in an
// intermediate state for more than 5 seconds.
constexpr base::TimeDelta kReportLingeringStateDelay = base::Milliseconds(5000);

// Delay threshold after the keyboard enters the WILL_HIDE state. If text focus
// is regained during this threshold, the keyboard will show again, even if it
// is an asynchronous event. This is for the benefit of things like login flow
// where the password field may get text focus after an animation that plays
// after the user enters their username.
constexpr base::TimeDelta kTransientBlurThreshold = base::Milliseconds(3500);

class VirtualKeyboardController : public ui::VirtualKeyboardController {
 public:
  explicit VirtualKeyboardController(
      KeyboardUIController* keyboard_ui_controller)
      : keyboard_ui_controller_(keyboard_ui_controller) {}

  ~VirtualKeyboardController() override = default;

  // ui::VirtualKeyboardController
  bool DisplayVirtualKeyboard() override {
    // Calling |ShowKeyboardInternal| may move the keyboard to another display.
    if (keyboard_ui_controller_->IsEnabled() &&
        !keyboard_ui_controller_->keyboard_locked()) {
      keyboard_ui_controller_->ShowKeyboard(false /* locked */);
      for (auto& observer : observer_list_) {
        observer.OnKeyboardVisible(gfx::Rect());
      }
      return true;
    }
    return false;
  }

  void DismissVirtualKeyboard() override {
    keyboard_ui_controller_->HideKeyboardByUser();
    for (auto& observer : observer_list_) {
      observer.OnKeyboardHidden();
    }
  }

  void AddObserver(ui::VirtualKeyboardControllerObserver* observer) override {
    observer_list_.AddObserver(observer);
  }

  void RemoveObserver(
      ui::VirtualKeyboardControllerObserver* observer) override {
    observer_list_.RemoveObserver(observer);
  }

  bool IsKeyboardVisible() override {
    return keyboard_ui_controller_->IsKeyboardVisible();
  }

 private:
  raw_ptr<KeyboardUIController> keyboard_ui_controller_;
  base::ObserverList<ui::VirtualKeyboardControllerObserver>::Unchecked
      observer_list_;
};

}  // namespace

// Observer for both keyboard show and hide animations. It should be owned by
// KeyboardUIController.
class CallbackAnimationObserver : public ui::ImplicitAnimationObserver {
 public:
  explicit CallbackAnimationObserver(base::OnceClosure callback)
      : callback_(std::move(callback)) {}

  CallbackAnimationObserver(const CallbackAnimationObserver&) = delete;
  CallbackAnimationObserver& operator=(const CallbackAnimationObserver&) =
      delete;

 private:
  // ui::ImplicitAnimationObserver:
  void OnImplicitAnimationsCompleted() override {
    if (WasAnimationAbortedForProperty(ui::LayerAnimationElement::TRANSFORM) ||
        WasAnimationAbortedForProperty(ui::LayerAnimationElement::OPACITY)) {
      return;
    }
    DCHECK(
        WasAnimationCompletedForProperty(ui::LayerAnimationElement::TRANSFORM));
    DCHECK(
        WasAnimationCompletedForProperty(ui::LayerAnimationElement::OPACITY));
    std::move(callback_).Run();
  }

  base::OnceClosure callback_;
};

KeyboardUIController::KeyboardUIController()
    : virtual_keyboard_controller_(
          std::make_unique<VirtualKeyboardController>(this)) {
  DCHECK_EQ(g_keyboard_controller, nullptr);
  g_keyboard_controller = this;
}

KeyboardUIController::~KeyboardUIController() {
  DCHECK(g_keyboard_controller);
  DCHECK(!ui_) << "Keyboard UI must be destroyed before KeyboardUIController "
                  "is destroyed";
  g_keyboard_controller = nullptr;
}

// static
KeyboardUIController* KeyboardUIController::Get() {
  DCHECK(g_keyboard_controller);
  return g_keyboard_controller;
}

// static
bool KeyboardUIController::HasInstance() {
  return g_keyboard_controller;
}

void KeyboardUIController::Initialize(
    std::unique_ptr<KeyboardUIFactory> ui_factory,
    KeyboardLayoutDelegate* layout_delegate) {
  DCHECK(ui_factory);
  DCHECK(layout_delegate);

  ui_factory_ = std::move(ui_factory);
  layout_delegate_ = layout_delegate;

  DCHECK(!IsKeyboardEnableRequested());
}

void KeyboardUIController::Shutdown() {
  keyboard_enable_flags_.clear();
  EnableFlagsChanged();

  DCHECK(!IsKeyboardEnableRequested());
  DisableKeyboard();
}

void KeyboardUIController::EnableKeyboard() {
  if (ui_)
    return;

  ui_ = ui_factory_->CreateKeyboardUI();
  DCHECK(ui_);

  show_on_keyboard_window_load_ = false;
  keyboard_locked_ = false;
  DCHECK_EQ(model_.state(), KeyboardUIState::kInitial);
  ui_->SetController(this);
  SetContainerBehaviorInternal(ContainerType::kFullWidth);
  visual_bounds_in_root_ = gfx::Rect();
  time_of_last_blur_ = base::Time::UnixEpoch();
  UpdateInputMethodObserver();

  ActivateKeyboardInContainer(
      layout_delegate_->GetContainerForDefaultDisplay());

  // Start preloading the virtual keyboard UI in the background, so that it
  // shows up faster when needed.
  LoadKeyboardWindowInBackground();

  // Notify observers after the keyboard window has a root window.
  for (auto& observer : observer_list_)
    observer.OnKeyboardEnabledChanged(true);
}

void KeyboardUIController::DisableKeyboard() {
  if (!ui_)
    return;

  if (parent_container_)
    DeactivateKeyboard();

  aura::Window* keyboard_window = GetKeyboardWindow();
  if (keyboard_window)
    keyboard_window->RemoveObserver(this);

  // Return to the INITIAL state to ensure that transitions entering a state
  // is equal to transitions leaving the state.
  if (model_.state() != KeyboardUIState::kInitial)
    ChangeState(KeyboardUIState::kInitial);

  // TODO(crbug.com/40524972): Move KeyboardUIController members into a
  // subobject so we can just put this code into the subobject destructor.
  queued_display_change_.reset();
  queued_container_type_.reset();
  container_behavior_.reset();
  animation_observer_.reset();

  ime_observation_.Reset();
  ui_->SetController(nullptr);
  ui_.reset();

  // Notify observers after |ui_| is reset so that IsEnabled() is false.
  for (auto& observer : observer_list_)
    observer.OnKeyboardEnabledChanged(false);
}

void KeyboardUIController::ActivateKeyboardInContainer(aura::Window* parent) {
  DCHECK(parent);
  DCHECK(!parent_container_);
  parent_container_ = parent;
  // Observe changes to root window bounds.
  parent_container_->GetRootWindow()->AddObserver(this);

  UpdateInputMethodObserver();

  if (GetKeyboardWindow()) {
    DCHECK(!GetKeyboardWindow()->parent());
    parent_container_->AddChild(GetKeyboardWindow());
  }
}

void KeyboardUIController::DeactivateKeyboard() {
  DCHECK(parent_container_);

  // Ensure the keyboard is not visible before deactivating it.
  HideKeyboardExplicitlyBySystem();

  aura::Window* keyboard_window = GetKeyboardWindow();
  if (keyboard_window) {
    keyboard_window->RemovePreTargetHandler(&event_handler_);
    if (keyboard_window->parent()) {
      DCHECK_EQ(parent_container_, keyboard_window->parent());
      parent_container_->RemoveChild(keyboard_window);
    }
  }
  aura::Window* root_window = parent_container_->GetRootWindow();
  if (root_window) {
    root_window->RemoveObserver(this);
  }
  parent_container_ = nullptr;
}

aura::Window* KeyboardUIController::GetKeyboardWindow() const {
  return ui_ ? ui_->GetKeyboardWindow() : nullptr;
}

ui::GestureConsumer* KeyboardUIController::GetGestureConsumer() const {
  return ui_ ? ui_->GetGestureConsumer() : nullptr;
}

aura::Window* KeyboardUIController::GetRootWindow() const {
  return parent_container_ ? parent_container_->GetRootWindow() : nullptr;
}

void KeyboardUIController::MoveToParentContainer(aura::Window* parent) {
  DCHECK(parent);
  if (parent_container_ == parent)
    return;

  TRACE_EVENT0("vk", "MoveKeyboardToDisplayInternal");

  DeactivateKeyboard();
  ActivateKeyboardInContainer(parent);
}

// private
void KeyboardUIController::NotifyKeyboardBoundsChanging(
    const gfx::Rect& new_bounds_in_root,
    bool is_temporary) {
  gfx::Rect occluded_bounds_in_screen;
  aura::Window* window = GetKeyboardWindow();
  if (window && window->IsVisible()) {
    visual_bounds_in_root_ = new_bounds_in_root;

    // |visual_bounds_in_root_| affects the result of
    // GetWorkspaceOccludedBoundsInScreen. Calculate |occluded_bounds_in_screen|
    // after updating |visual_bounds_in_root_|.
    // TODO(andrewxu): Add the unit test case for issue 960174.
    occluded_bounds_in_screen = GetWorkspaceOccludedBoundsInScreen();

    // TODO(crbug.com/40619022): Use screen bounds for visual bounds.
    notification_manager_.SendNotifications(
        container_behavior_->OccludedBoundsAffectWorkspaceLayout(),
        new_bounds_in_root, occluded_bounds_in_screen, is_temporary,
        observer_list_);
  } else {
    visual_bounds_in_root_ = gfx::Rect();
    occluded_bounds_in_screen = GetWorkspaceOccludedBoundsInScreen();
  }

  EnsureCaretInWorkArea(occluded_bounds_in_screen);
}

void KeyboardUIController::SetKeyboardWindowBounds(
    const gfx::Rect& new_bounds_in_root) {
  ui::LayerAnimator* animator = GetKeyboardWindow()->layer()->GetAnimator();
  // Stops previous animation if a window resize is requested during animation.
  if (animator->is_animating())
    animator->StopAnimating();

  GetKeyboardWindow()->SetBounds(new_bounds_in_root);
}

void KeyboardUIController::NotifyKeyboardWindowLoaded() {
  const bool should_show = show_on_keyboard_window_load_;
  if (model_.state() == KeyboardUIState::kLoading)
    ChangeState(KeyboardUIState::kHidden);
  if (should_show) {
    // The window height is set to 0 initially or before switch to an IME in a
    // different extension. Virtual keyboard window may wait for this bounds
    // change to correctly animate in.
    if (keyboard_locked_) {
      // Do not move the keyboard to another display after switch to an IME in
      // a different extension.
      ShowKeyboardInDisplay(
          display_util_.GetNearestDisplayToWindow(GetKeyboardWindow()));
    } else {
      ShowKeyboard(false /* lock */);
    }
  }
}

void KeyboardUIController::Reload() {
  if (!GetKeyboardWindow())
    return;

  ui_->ReloadKeyboardIfNeeded();
}

void KeyboardUIController::RebuildKeyboardIfEnabled() {
  if (!IsEnabled())
    return;

  DisableKeyboard();
  EnableKeyboard();
}

void KeyboardUIController::AddObserver(
    ash::KeyboardControllerObserver* observer) {
  observer_list_.AddObserver(observer);
}

bool KeyboardUIController::HasObserver(
    ash::KeyboardControllerObserver* observer) const {
  return observer_list_.HasObserver(observer);
}

void KeyboardUIController::RemoveObserver(
    ash::KeyboardControllerObserver* observer) {
  observer_list_.RemoveObserver(observer);
}

bool KeyboardUIController::UpdateKeyboardConfig(const KeyboardConfig& config) {
  if (config == keyboard_config_)
    return false;
  keyboard_config_ = config;
  if (IsEnabled())
    NotifyKeyboardConfigChanged();
  return true;
}

void KeyboardUIController::SetEnableFlag(KeyboardEnableFlag flag) {
  if (!base::Contains(keyboard_enable_flags_, flag))
    keyboard_enable_flags_.insert(flag);

  // If there is a flag that is mutually exclusive with |flag|, clear it.
  switch (flag) {
    case KeyboardEnableFlag::kPolicyEnabled:
      keyboard_enable_flags_.erase(KeyboardEnableFlag::kPolicyDisabled);
      break;
    case KeyboardEnableFlag::kPolicyDisabled:
      keyboard_enable_flags_.erase(KeyboardEnableFlag::kPolicyEnabled);
      break;
    case KeyboardEnableFlag::kExtensionEnabled:
      keyboard_enable_flags_.erase(KeyboardEnableFlag::kExtensionDisabled);
      break;
    case KeyboardEnableFlag::kExtensionDisabled:
      keyboard_enable_flags_.erase(KeyboardEnableFlag::kExtensionEnabled);
      break;
    default:
      break;
  }

  EnableFlagsChanged();

  UpdateKeyboardAsRequestedBy(flag);
}

void KeyboardUIController::ClearEnableFlag(KeyboardEnableFlag flag) {
  if (!IsEnableFlagSet(flag))
    return;

  keyboard_enable_flags_.erase(flag);
  EnableFlagsChanged();

  UpdateKeyboardAsRequestedBy(flag);
}

bool KeyboardUIController::IsEnableFlagSet(KeyboardEnableFlag flag) const {
  return base::Contains(keyboard_enable_flags_, flag);
}

bool KeyboardUIController::IsKeyboardEnableRequested() const {
  // Accessibility setting prioritized over policy/arc overrides.
  if (IsEnableFlagSet(KeyboardEnableFlag::kAccessibilityEnabled))
    return true;

  // Keyboard can be enabled temporarily by the shelf.
  if (IsEnableFlagSet(KeyboardEnableFlag::kShelfEnabled))
    return true;

  if (IsEnableFlagSet(KeyboardEnableFlag::kAndroidDisabled) ||
      IsEnableFlagSet(KeyboardEnableFlag::kPolicyDisabled)) {
    return false;
  }
  if (IsEnableFlagSet(KeyboardEnableFlag::kPolicyEnabled))
    return true;

  // Command line overrides extension and touch enabled flags.
  if (IsEnableFlagSet(KeyboardEnableFlag::kCommandLineEnabled))
    return true;

  if (IsEnableFlagSet(KeyboardEnableFlag::kCommandLineDisabled))
    return false;

  if (IsEnableFlagSet(KeyboardEnableFlag::kExtensionDisabled))
    return false;

  return IsEnableFlagSet(KeyboardEnableFlag::kExtensionEnabled) ||
         IsEnableFlagSet(KeyboardEnableFlag::kTouchEnabled);
}

void KeyboardUIController::UpdateKeyboardAsRequestedBy(
    KeyboardEnableFlag flag) {
  this->NotifyKeyboardConfigChanged();
  if (IsKeyboardEnableRequested()) {
    // Note that there are two versions of the on-screen keyboard. A full layout
    // is provided for accessibility, which includes sticky modifier keys to
    // enable typing of hotkeys. A compact version is used in tablet mode to
    // provide a layout with larger keys to facilitate touch typing. In the
    // event that the a11y keyboard is being disabled, an on-screen keyboard
    // might still be enabled and a forced reset is required to pick up the
    // layout change.
    if (IsEnabled() && flag == KeyboardEnableFlag::kAccessibilityEnabled)
      RebuildKeyboardIfEnabled();
    else
      EnableKeyboard();
  } else {
    DisableKeyboard();
  }
}

bool KeyboardUIController::IsKeyboardOverscrollEnabled() const {
  if (!IsEnabled())
    return false;

  // Users of the sticky accessibility on-screen keyboard are likely to be using
  // mouse input, which may interfere with overscrolling.
  if (IsEnabled() && !IsOverscrollAllowed())
    return false;

  // If overscroll enabled behavior is set, use it instead. Currently
  // login / out-of-box disable keyboard overscroll. http://crbug.com/363635
  if (keyboard_config_.overscroll_behavior !=
      KeyboardOverscrollBehavior::kDefault) {
    return keyboard_config_.overscroll_behavior ==
           KeyboardOverscrollBehavior::kEnabled;
  }

  return true;
}

// private
void KeyboardUIController::HideKeyboard(HideReason reason) {
  TRACE_EVENT0("vk", "HideKeyboard");

  // Decide whether regaining focus in a web-based text field should cause
  // the keyboard to come back.
  switch (reason) {
    case HIDE_REASON_SYSTEM_IMPLICIT:
      time_of_last_blur_ = base::Time::Now();
      break;

    case HIDE_REASON_SYSTEM_TEMPORARY:
    case HIDE_REASON_SYSTEM_EXPLICIT:
    case HIDE_REASON_USER_EXPLICIT:
    case HIDE_REASON_USER_IMPLICIT:
      time_of_last_blur_ = base::Time::UnixEpoch();
      break;
  }

  switch (model_.state()) {
    case KeyboardUIState::kUnknown:
    case KeyboardUIState::kInitial:
    case KeyboardUIState::kHidden:
      return;
    case KeyboardUIState::kLoading:
      show_on_keyboard_window_load_ = false;
      return;

    case KeyboardUIState::kWillHide:
    case KeyboardUIState::kShown: {
      NotifyKeyboardBoundsChanging(gfx::Rect(),
                                   reason == HIDE_REASON_SYSTEM_TEMPORARY);

      set_keyboard_locked(false);

      aura::Window* window = GetKeyboardWindow();
      DCHECK(window);

      animation_observer_ = std::make_unique<CallbackAnimationObserver>(
          base::BindOnce(&KeyboardUIController::HideAnimationFinished,
                         base::Unretained(this)));
      ui::ScopedLayerAnimationSettings layer_animation_settings(
          window->layer()->GetAnimator());
      layer_animation_settings.AddObserver(animation_observer_.get());

      {
        // Scoped settings go into effect when scope ends.
        ::wm::ScopedHidingAnimationSettings hiding_settings(window);
        container_behavior_->DoHidingAnimation(window, &hiding_settings);
      }

      ui_->HideKeyboardWindow();
      ChangeState(KeyboardUIState::kHidden);

      for (auto& observer : observer_list_)
        observer.OnKeyboardHidden(reason == HIDE_REASON_SYSTEM_TEMPORARY);

      break;
    }
  }
}

void KeyboardUIController::HideKeyboardByUser() {
  HideKeyboard(HIDE_REASON_USER_EXPLICIT);
}

void KeyboardUIController::HideKeyboardImplicitlyByUser() {
  if (!keyboard_locked_)
    HideKeyboard(HIDE_REASON_USER_IMPLICIT);
}

void KeyboardUIController::HideKeyboardTemporarilyForTransition() {
  HideKeyboard(HIDE_REASON_SYSTEM_TEMPORARY);
}

void KeyboardUIController::HideKeyboardExplicitlyBySystem() {
  HideKeyboard(HIDE_REASON_SYSTEM_EXPLICIT);
}

void KeyboardUIController::HideKeyboardImplicitlyBySystem() {
  if (model_.state() != KeyboardUIState::kShown || keyboard_locked_)
    return;

  ChangeState(KeyboardUIState::kWillHide);

  base::SingleThreadTaskRunner::GetCurrentDefault()->PostDelayedTask(
      FROM_HERE,
      base::BindOnce(&KeyboardUIController::HideKeyboard,
                     weak_factory_will_hide_.GetWeakPtr(),
                     HIDE_REASON_SYSTEM_IMPLICIT),
      kHideKeyboardDelay);
}

// private
void KeyboardUIController::HideAnimationFinished() {
  if (model_.state() == KeyboardUIState::kHidden) {
    if (queued_container_type_) {
      SetContainerBehaviorInternal(queued_container_type_->container_type());
      // The position of the container window will be adjusted shortly in
      // |PopulateKeyboardContent| before showing animation, so we can set the
      // passed bounds directly.
      SetKeyboardWindowBounds(queued_container_type_->target_bounds());
      ShowKeyboard(false /* lock */);
    }

    if (queued_display_change_) {
      ShowKeyboardInDisplay(queued_display_change_->new_display());
      SetKeyboardWindowBounds(queued_display_change_->new_bounds_in_local());
      queued_display_change_ = nullptr;
    }
  }
}

// private
void KeyboardUIController::ShowAnimationFinished() {
  // Notify observers after animation finished to prevent reveal desktop
  // background during animation.
  // If the current state is not SHOWN, it means the state was changed after the
  // animation started. Do not tell the observers the stale bounds.
  if (model_.state() == KeyboardUIState::kShown)
    NotifyKeyboardBoundsChanging(GetKeyboardWindow()->GetBoundsInRootWindow());
}

// private
void KeyboardUIController::SetContainerBehaviorInternal(ContainerType type) {
  // Reset the hit test event targeter because the hit test bounds will
  // be wrong when container type changes and may cause the UI to be unusable.
  if (GetKeyboardWindow())
    GetKeyboardWindow()->SetEventTargeter(nullptr);

  switch (type) {
    case ContainerType::kFullWidth:
      container_behavior_ = std::make_unique<ContainerFullWidthBehavior>(this);
      break;
    case ContainerType::kFloating:
      container_behavior_ = std::make_unique<ContainerFloatingBehavior>(this);
      break;
  }
}

void KeyboardUIController::ShowKeyboard(bool lock) {
  // TODO(b/245019967): Delete lock arg.
  // Outside of unittests, this function is only ever called with
  // lock = false.
  // Maybe it could be refactored to not support the lock = true case.
  DVLOG(1) << "ShowKeyboard";
  set_keyboard_locked(lock);
  ShowKeyboardInternal(layout_delegate_->GetContainerForDefaultDisplay());
}

void KeyboardUIController::ShowKeyboardInDisplay(
    const display::Display& display) {
  DVLOG(1) << "ShowKeyboardInDisplay: " << display.id();
  set_keyboard_locked(true);
  ShowKeyboardInternal(layout_delegate_->GetContainerForDisplay(display));
}

gfx::Rect KeyboardUIController::GetVisualBoundsInScreen() const {
  gfx::Rect visual_bounds_in_screen = visual_bounds_in_root_;
  ::wm::ConvertRectToScreen(GetRootWindow(), &visual_bounds_in_screen);
  return visual_bounds_in_screen;
}

void KeyboardUIController::LoadKeyboardWindowInBackground() {
  DCHECK_EQ(model_.state(), KeyboardUIState::kInitial);

  TRACE_EVENT0("vk", "LoadKeyboardWindowInBackground");

  // For now, using Unretained is safe here because the |ui_| is owned by
  // |this| and the callback does not outlive |ui_|.
  // TODO(crbug.com/40577582): Use a weak ptr here in case this
  // assumption changes.
  DVLOG(1) << "LoadKeyboardWindow";
  aura::Window* keyboard_window = ui_->LoadKeyboardWindow(
      base::BindOnce(&KeyboardUIController::NotifyKeyboardWindowLoaded,
                     base::Unretained(this)));
  keyboard_window->AddPreTargetHandler(&event_handler_);
  keyboard_window->AddObserver(this);
  parent_container_->AddChild(keyboard_window);

  ChangeState(KeyboardUIState::kLoading);
}

ui::InputMethod* KeyboardUIController::GetInputMethodForTest() {
  return ui_->GetInputMethod();
}

void KeyboardUIController::EnsureCaretInWorkAreaForTest(
    const gfx::Rect& occluded_bounds_in_screen) {
  EnsureCaretInWorkArea(occluded_bounds_in_screen);
}

// ContainerBehavior::Delegate overrides

bool KeyboardUIController::IsKeyboardLocked() const {
  return keyboard_locked_;
}

gfx::Rect KeyboardUIController::GetBoundsInScreen() const {
  return GetKeyboardWindow()->GetBoundsInScreen();
}

void KeyboardUIController::MoveKeyboardWindow(const gfx::Rect& new_bounds) {
  DCHECK(IsKeyboardVisible());
  SetKeyboardWindowBounds(new_bounds);
}

void KeyboardUIController::MoveKeyboardWindowToDisplay(
    const display::Display& display,
    const gfx::Rect& new_bounds_in_root) {
  queued_display_change_ =
      std::make_unique<QueuedDisplayChange>(display, new_bounds_in_root);
  HideKeyboardTemporarilyForTransition();
}

void KeyboardUIController::TransferGestureEventToShelf(
    const ui::GestureEvent& e) {
  layout_delegate_->TransferGestureEventToShelf(e);
}

// aura::WindowObserver overrides

void KeyboardUIController::OnWindowAddedToRootWindow(aura::Window* window) {
  container_behavior_->SetCanonicalBounds(GetKeyboardWindow(),
                                          GetRootWindow()->bounds());
}

void KeyboardUIController::OnWindowBoundsChanged(
    aura::Window* window,
    const gfx::Rect& old_bounds_in_root,
    const gfx::Rect& new_bounds_in_root,
    ui::PropertyChangeReason reason) {
  if (!GetKeyboardWindow())
    return;

  // |window| could be the root window (for detecting screen rotations) or the
  // keyboard window (for detecting keyboard bounds changes).
  if (window == GetRootWindow())
    container_behavior_->SetCanonicalBounds(GetKeyboardWindow(),
                                            new_bounds_in_root);
  else if (window == GetKeyboardWindow())
    NotifyKeyboardBoundsChanging(new_bounds_in_root);
}

// InputMethodObserver overrides

void KeyboardUIController::OnInputMethodDestroyed(
    const ui::InputMethod* input_method) {
  ime_observation_.Reset();
  OnTextInputStateChanged(nullptr);
}

void KeyboardUIController::OnTextInputStateChanged(
    const ui::TextInputClient* client) {
  TRACE_EVENT0("vk", "OnTextInputStateChanged");

  bool focused =
      client && (client->GetTextInputType() != ui::TEXT_INPUT_TYPE_NONE &&
                 client->GetTextInputMode() != ui::TEXT_INPUT_MODE_NONE);
  bool should_hide = !focused && container_behavior_->TextBlurHidesKeyboard();
  bool is_web =
      client && client->GetTextInputFlags() != ui::TEXT_INPUT_FLAG_NONE;

  if (should_hide) {
    switch (model_.state()) {
      case KeyboardUIState::kLoading:
        show_on_keyboard_window_load_ = false;
        return;
      case KeyboardUIState::kShown:
        HideKeyboardImplicitlyBySystem();
        return;
      default:
        return;
    }
  } else {
    switch (model_.state()) {
      case KeyboardUIState::kWillHide:
        // Abort a pending keyboard hide.
        ChangeState(KeyboardUIState::kShown);
        return;
      case KeyboardUIState::kHidden:
        if (focused && is_web)
          ShowKeyboardIfWithinTransientBlurThreshold();
        return;
      default:
        break;
    }
    // Do not explicitly show the Virtual keyboard unless it is in the process
    // of hiding or the hide duration was very short (transient blur). Instead,
    // the virtual keyboard is shown in response to a user gesture (mouse or
    // touch) that is received while an element has input focus. Showing the
    // keyboard requires an explicit call to
    // OnVirtualKeyboardVisibilityChangedIfEnabled.
  }
}

void KeyboardUIController::ShowKeyboardIfWithinTransientBlurThreshold() {
  if (should_show_on_transient_blur_ &&
      base::Time::Now() - time_of_last_blur_ < kTransientBlurThreshold) {
    ShowKeyboard(false);
  }
}

void KeyboardUIController::SetShouldShowOnTransientBlur(bool should_show) {
  should_show_on_transient_blur_ = should_show;
}

void KeyboardUIController::OnVirtualKeyboardVisibilityChangedIfEnabled(
    bool should_show) {
  if (should_show) {
    DVLOG(1) << "OnVirtualKeyboardVisibilityChangedIfEnabled: " << IsEnabled();
    // Calling |ShowKeyboardInternal| may move the keyboard to another display.
    if (IsEnabled() && !keyboard_locked_)
      ShowKeyboardInternal(layout_delegate_->GetContainerForDefaultDisplay());
  } else {
    HideKeyboardExplicitlyBySystem();
  }
}

void KeyboardUIController::ShowKeyboardInternal(
    aura::Window* target_container) {
  PopulateKeyboardContent(target_container);
  UpdateInputMethodObserver();
}

void KeyboardUIController::PopulateKeyboardContent(
    aura::Window* target_container) {
  DCHECK_NE(model_.state(), KeyboardUIState::kInitial);

  DVLOG(1) << "PopulateKeyboardContent: " << StateToStr(model_.state());
  TRACE_EVENT0("vk", "PopulateKeyboardContent");

  MoveToParentContainer(target_container);

  aura::Window* keyboard_window = GetKeyboardWindow();
  DCHECK(keyboard_window);
  DCHECK_EQ(parent_container_, keyboard_window->parent());

  switch (model_.state()) {
    case KeyboardUIState::kShown:
      return;
    case KeyboardUIState::kLoading:
      show_on_keyboard_window_load_ = true;
      return;
    default:
      break;
  }

  ui_->ReloadKeyboardIfNeeded();

  switch (model_.state()) {
    case KeyboardUIState::kWillHide:
      ChangeState(KeyboardUIState::kShown);
      return;
    default:
      break;
  }

  DCHECK_EQ(model_.state(), KeyboardUIState::kHidden);

  // If the container is not animating, makes sure the position and opacity
  // are at begin states for animation.
  container_behavior_->InitializeShowAnimationStartingState(keyboard_window);

  RecordUkmKeyboardShown();

  ui::LayerAnimator* container_animator =
      keyboard_window->layer()->GetAnimator();
  container_animator->set_preemption_strategy(
      ui::LayerAnimator::IMMEDIATELY_ANIMATE_TO_NEW_TARGET);

  ui_->ShowKeyboardWindow();

  animation_observer_ = std::make_unique<CallbackAnimationObserver>(
      base::BindOnce(&KeyboardUIController::ShowAnimationFinished,
                     base::Unretained(this)));
  ui::ScopedLayerAnimationSettings settings(container_animator);
  settings.AddObserver(animation_observer_.get());

  container_behavior_->DoShowingAnimation(keyboard_window, &settings);

  // the queued container behavior will notify JS to change layout when it
  // gets destroyed.
  queued_container_type_ = nullptr;

  ChangeState(KeyboardUIState::kShown);

  UMA_HISTOGRAM_ENUMERATION("InputMethod.VirtualKeyboard.ContainerBehavior",
                            GetActiveContainerType());
}

bool KeyboardUIController::WillHideKeyboard() const {
  bool res = weak_factory_will_hide_.HasWeakPtrs();
  DCHECK_EQ(res, model_.state() == KeyboardUIState::kWillHide);
  return res;
}

void KeyboardUIController::NotifyKeyboardConfigChanged() {
  for (auto& observer : observer_list_)
    observer.OnKeyboardConfigChanged(keyboard_config_);
}

void KeyboardUIController::ChangeState(KeyboardUIState state) {
  model_.ChangeState(state);

  if (state != KeyboardUIState::kWillHide)
    weak_factory_will_hide_.InvalidateWeakPtrs();
  if (state != KeyboardUIState::kLoading)
    show_on_keyboard_window_load_ = false;

  weak_factory_report_lingering_state_.InvalidateWeakPtrs();
  switch (model_.state()) {
    case KeyboardUIState::kLoading:
    case KeyboardUIState::kWillHide:
      base::SingleThreadTaskRunner::GetCurrentDefault()->PostDelayedTask(
          FROM_HERE,
          base::BindOnce(&KeyboardUIController::ReportLingeringState,
                         weak_factory_report_lingering_state_.GetWeakPtr()),
          kReportLingeringStateDelay);
      break;
    default:
      // Do nothing
      break;
  }
}

void KeyboardUIController::ReportLingeringState() {
  LOG(ERROR) << "KeyboardUIController lingering in "
             << StateToStr(model_.state());
}

gfx::Rect KeyboardUIController::GetWorkspaceOccludedBoundsInScreen() const {
  // TODO(crbug.com/1157150): Investigate why the keyboard window or its root
  // window is null or missing a ScreenPositionClient when adding a new monitor.
  if (!ui_ || !GetKeyboardWindow() || !GetKeyboardWindow()->GetRootWindow() ||
      !aura::client::GetScreenPositionClient(
          GetKeyboardWindow()->GetRootWindow())) {
    return gfx::Rect();
  }

  const gfx::Rect visual_bounds_in_window(visual_bounds_in_root_.size());

  gfx::Rect occluded_bounds_in_screen =
      container_behavior_->GetOccludedBounds(visual_bounds_in_window);
  ::wm::ConvertRectToScreen(GetKeyboardWindow(), &occluded_bounds_in_screen);

  return occluded_bounds_in_screen;
}

gfx::Rect KeyboardUIController::GetKeyboardLockScreenOffsetBounds() const {
  // Overscroll is generally dependent on lock state, however, its behavior
  // temporarily overridden by a static field in certain lock screen contexts.
  // Furthermore, floating keyboard should never affect layout.
  if (!IsKeyboardOverscrollEnabled() &&
      container_behavior_->GetType() != ContainerType::kFloating) {
    return visual_bounds_in_root_;
  }
  return gfx::Rect();
}

void KeyboardUIController::SetOccludedBounds(
    const gfx::Rect& bounds_in_window) {
  container_behavior_->SetOccludedBounds(bounds_in_window);

  // Notify that only the occluded bounds have changed.
  if (IsKeyboardVisible())
    NotifyKeyboardBoundsChanging(visual_bounds_in_root_);
}

void KeyboardUIController::SetHitTestBounds(
    const std::vector<gfx::Rect>& bounds_in_window) {
  if (!GetKeyboardWindow())
    return;

  GetKeyboardWindow()->SetEventTargeter(
      std::make_unique<ShapedWindowTargeter>(bounds_in_window));
}

bool KeyboardUIController::SetAreaToRemainOnScreen(
    const gfx::Rect& bounds_in_window) {
  gfx::Rect window_bounds_in_screen = GetKeyboardWindow()->GetBoundsInScreen();
  gfx::Rect bounds_in_screen =
      gfx::Rect(window_bounds_in_screen.x() + bounds_in_window.x(),
                window_bounds_in_screen.y() + bounds_in_window.y(),
                bounds_in_window.width(), bounds_in_window.height());

  if (!window_bounds_in_screen.Contains(bounds_in_screen))
    return false;

  container_behavior_->SetAreaToRemainOnScreen(bounds_in_window);
  return true;
}

bool KeyboardUIController::SetKeyboardWindowBoundsInScreen(
    const gfx::Rect& bounds_in_screen) {
  const display::Display& current_display =
      display_util_.GetNearestDisplayToWindow(GetRootWindow());

  gfx::Rect display_bounds = current_display.bounds();
  if (bounds_in_screen.width() > display_bounds.width() ||
      bounds_in_screen.height() > display_bounds.height()) {
    return false;
  }

  gfx::Rect constrained_bounds_in_screen =
      AdjustSetBoundsRequest(current_display.bounds(), bounds_in_screen);

  GetKeyboardWindow()->SetBoundsInScreen(constrained_bounds_in_screen,
                                         current_display);
  return true;
}

gfx::Rect KeyboardUIController::AdjustSetBoundsRequest(
    const gfx::Rect& display_bounds,
    const gfx::Rect& requested_bounds_in_screen) const {
  return container_behavior_->AdjustSetBoundsRequest(
      display_bounds, requested_bounds_in_screen);
}

bool KeyboardUIController::IsOverscrollAllowed() const {
  return container_behavior_->IsOverscrollAllowed();
}

bool KeyboardUIController::HandlePointerEvent(const ui::LocatedEvent& event) {
  const display::Display& current_display =
      display_util_.GetNearestDisplayToWindow(GetRootWindow());
  return container_behavior_->HandlePointerEvent(event, current_display);
}

bool KeyboardUIController::HandleGestureEvent(const ui::GestureEvent& event) {
  return container_behavior_->HandleGestureEvent(event, GetBoundsInScreen());
}

void KeyboardUIController::SetContainerType(
    ContainerType type,
    const gfx::Rect& target_bounds_in_root,
    base::OnceCallback<void(bool)> callback) {
  if (container_behavior_->GetType() == type) {
    std::move(callback).Run(false);
    return;
  }

  if (model_.state() == KeyboardUIState::kShown) {
    // Keyboard is already shown. Hiding the keyboard at first then switching
    // container type.
    queued_container_type_ = std::make_unique<QueuedContainerType>(
        this, type, target_bounds_in_root, std::move(callback));
    HideKeyboard(HIDE_REASON_SYSTEM_TEMPORARY);
  } else {
    // Keyboard is hidden. Switching the container type immediately and invoking
    // the passed callback now.
    SetContainerBehaviorInternal(type);
    SetKeyboardWindowBounds(target_bounds_in_root);
    DCHECK_EQ(GetActiveContainerType(), type);
    std::move(callback).Run(true /* change_successful */);
  }
}

void KeyboardUIController::RecordUkmKeyboardShown() {
  ui::TextInputClient* text_input_client = GetTextInputClient();
  if (!text_input_client)
    return;

  keyboard::RecordUkmKeyboardShown(
      text_input_client->GetClientSourceForMetrics(),
      text_input_client->GetTextInputType());
}

void KeyboardUIController::SetDraggableArea(const gfx::Rect& rect) {
  container_behavior_->SetDraggableArea(rect);
}

bool KeyboardUIController::IsKeyboardVisible() {
  if (model_.state() == KeyboardUIState::kShown) {
    DCHECK(IsEnabled());
    return true;
  }
  return false;
}

ui::TextInputClient* KeyboardUIController::GetTextInputClient() {
  return ui_->GetInputMethod()->GetTextInputClient();
}

void KeyboardUIController::UpdateInputMethodObserver() {
  ui::InputMethod* ime = ui_->GetInputMethod();

  // IME could be null during initialization. Ignoring the case is okay because
  // UpdateInputMethodObserver() will be called later on.
  if (!ime)
    return;

  if (ime_observation_.IsObservingSource(ime))
    return;

  // Only observes the current active IME.
  ime_observation_.Reset();
  ime_observation_.Observe(ime);

  // Note: We used to call OnTextInputStateChanged(ime->GetTextInputClient())
  // here, but that can trigger HideKeyboardImplicitlyBySystem() from a call to
  // ShowKeyboard() when using mojo APIs in Chrome (SingleProcessMash) if
  // ime->GetTextInputClient() isn't focused.
}

void KeyboardUIController::EnsureCaretInWorkArea(
    const gfx::Rect& occluded_bounds_in_screen) {
  ui::InputMethod* ime = ui_->GetInputMethod();
  if (!ime)
    return;

  TRACE_EVENT0("vk", "EnsureCaretInWorkArea");

  if (IsOverscrollAllowed()) {
    ime->SetVirtualKeyboardBounds(occluded_bounds_in_screen);
  } else if (ime->GetTextInputClient()) {
    ime->GetTextInputClient()->EnsureCaretNotInRect(occluded_bounds_in_screen);
  }
}

void KeyboardUIController::EnableFlagsChanged() {
  for (auto& observer : observer_list_)
    observer.OnKeyboardEnableFlagsChanged(keyboard_enable_flags_);
}

}  // namespace keyboard