ash / wm / tablet_mode / tablet_mode_controller.cc [blame]

// Copyright 2014 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/wm/tablet_mode/tablet_mode_controller.h"

#include <algorithm>
#include <string>
#include <utility>

#include "ash/accessibility/accessibility_controller.h"
#include "ash/app_menu/menu_util.h"
#include "ash/constants/ash_switches.h"
#include "ash/login_status.h"
#include "ash/public/cpp/metrics_util.h"
#include "ash/public/cpp/shelf_config.h"
#include "ash/public/cpp/shell_window_ids.h"
#include "ash/public/cpp/tablet_mode_observer.h"
#include "ash/shelf/shelf.h"
#include "ash/shell.h"
#include "ash/shell_delegate.h"
#include "ash/strings/grit/ash_strings.h"
#include "ash/utility/layer_util.h"
#include "ash/wm/overview/overview_controller.h"
#include "ash/wm/splitview/split_view_utils.h"
#include "ash/wm/tablet_mode/internal_input_devices_event_blocker.h"
#include "ash/wm/tablet_mode/tablet_mode_window_manager.h"
#include "ash/wm/window_state.h"
#include "ash/wm/window_util.h"
#include "base/command_line.h"
#include "base/containers/contains.h"
#include "base/functional/bind.h"
#include "base/functional/callback.h"
#include "base/location.h"
#include "base/metrics/histogram.h"
#include "base/metrics/histogram_macros.h"
#include "base/metrics/user_metrics.h"
#include "base/notreached.h"
#include "base/system/sys_info.h"
#include "base/time/default_tick_clock.h"
#include "base/time/tick_clock.h"
#include "ui/aura/client/aura_constants.h"
#include "ui/aura/window_observer.h"
#include "ui/base/accelerators/accelerator.h"
#include "ui/base/l10n/l10n_util.h"
#include "ui/compositor/compositor.h"
#include "ui/compositor/layer.h"
#include "ui/compositor/layer_animation_sequence.h"
#include "ui/compositor/layer_animator.h"
#include "ui/display/display.h"
#include "ui/display/manager/display_manager.h"
#include "ui/display/screen.h"
#include "ui/display/tablet_state.h"
#include "ui/display/util/display_util.h"
#include "ui/events/devices/device_data_manager.h"
#include "ui/events/devices/input_device.h"
#include "ui/events/event.h"
#include "ui/events/keycodes/keyboard_codes.h"
#include "ui/views/widget/widget.h"
#include "ui/wm/core/cursor_manager.h"
#include "ui/wm/core/window_util.h"

#undef ENABLED_VLOG_LEVEL
#define ENABLED_VLOG_LEVEL 1

namespace ash {

BASE_FEATURE(kBlockUiTabletModeInKiosk,
             "BlockUiTabletModeInKiosk",
             base::FEATURE_ENABLED_BY_DEFAULT);

namespace {

// The hinge angle at which to enter tablet mode.
constexpr float kEnterTabletModeAngle = 200.0f;

// The angle at which to exit tablet mode, this is specifically less than the
// angle to enter tablet mode to prevent rapid toggling when near the angle.
constexpr float kExitTabletModeAngle = 160.0f;

// Defines a range for which accelerometer readings are considered accurate.
// When the lid is near open (or near closed) the accelerometer readings may be
// inaccurate and a lid that is fully open may appear to be near closed (and
// vice versa).
constexpr float kMinStableAngle = 20.0f;
constexpr float kMaxStableAngle = 340.0f;

// The time duration to consider an unstable lid angle to be valid. This is used
// to prevent entering tablet mode if an erroneous accelerometer reading makes
// the lid appear to be fully open when the user is opening the lid from a
// closed position or is closing the lid from an opened position.
constexpr base::TimeDelta kUnstableLidAngleDuration = base::Seconds(2);

// When the device approaches vertical orientation (i.e. portrait orientation)
// the accelerometers for the base and lid approach the same values (i.e.
// gravity pointing in the direction of the hinge). When this happens abrupt
// small acceleration perpendicular to the hinge can lead to incorrect hinge
// angle calculations. To prevent this the accelerometer updates will be
// smoothed over time in order to reduce this noise.
// This is the minimum acceleration parallel to the hinge under which to begin
// smoothing in m/s^2.
constexpr float kHingeVerticalSmoothingStart = 7.0f;
// This is the maximum acceleration parallel to the hinge under which smoothing
// will incorporate new acceleration values, in m/s^2.
constexpr float kHingeVerticalSmoothingMaximum = 8.7f;

// The maximum deviation between the magnitude of the two accelerometers under
// which to detect hinge angle in m/s^2. These accelerometers are attached to
// the same physical device and so should be under the same acceleration.
constexpr float kNoisyMagnitudeDeviation = 1.0f;

// Interval between calls to RecordLidAngle().
constexpr base::TimeDelta kRecordLidAngleInterval = base::Hours(1);

// Time that should wait to reset |occlusion_tracker_pauser_| on
// entering/exiting tablet mode.
constexpr base::TimeDelta kOcclusionTrackerTimeout = base::Seconds(1);

// Histogram names for recording animation smoothness when entering or exiting
// tablet mode.
constexpr char kTabletModeEnterHistogram[] =
    "Ash.TabletMode.AnimationSmoothness.Enter";
constexpr char kTabletModeExitHistogram[] =
    "Ash.TabletMode.AnimationSmoothness.Exit";

// Set to false for tests so tablet mode can be changed synchronously.
bool use_screenshot_for_test = true;

// The angle between AccelerometerReadings are considered stable if
// their magnitudes do not differ greatly. This returns false if the deviation
// between the screen and keyboard accelerometers is too high.
bool IsAngleBetweenAccelerometerReadingsStable(
    const AccelerometerUpdate& update) {
  return std::abs(
             update.GetVector(ACCELEROMETER_SOURCE_ATTACHED_KEYBOARD).Length() -
             update.GetVector(ACCELEROMETER_SOURCE_SCREEN).Length()) <=
         kNoisyMagnitudeDeviation;
}

// Returns the UiMode given by the force-table-mode command line.
TabletModeController::UiMode GetUiMode() {
  base::CommandLine* command_line = base::CommandLine::ForCurrentProcess();
  if (command_line->HasSwitch(switches::kAshUiMode)) {
    std::string switch_value =
        command_line->GetSwitchValueASCII(switches::kAshUiMode);
    if (switch_value == switches::kAshUiModeClamshell) {
      return TabletModeController::UiMode::kClamshell;
    }

    if (switch_value == switches::kAshUiModeTablet) {
      return TabletModeController::UiMode::kTabletMode;
    }
  }
  return TabletModeController::UiMode::kNone;
}

// Returns true if the device has an active internal display.
bool HasActiveInternalDisplay() {
  if (!display::HasInternalDisplay()) {
    return false;
  }

  display::DisplayManager* display_manager = Shell::Get()->display_manager();
  return display_manager->IsActiveDisplayId(
             display::Display::InternalDisplayId()) ||
         display_manager->IsInUnifiedMode();
}

// Returns true if |sequence| has the same properties as the ones we care about
// for the tablet transition animation.
bool ShouldObserveSequence(ui::LayerAnimationSequence* sequence) {
  DCHECK(sequence);
  return sequence->properties() &
         TabletModeController::GetObservedTabletTransitionProperty();
}

// Check if there is any external and internal pointing device in
// |input_devices|.
template <typename PointingDeviceType>
void CheckHasPointingDevices(
    const std::vector<PointingDeviceType>& input_devices,
    BluetoothDevicesObserver* bluetooth_device_observer,
    bool& out_has_external_pointing_device,
    bool& out_has_internal_pointing_device) {
  static_assert(std::is_base_of<ui::InputDevice, PointingDeviceType>::value);
  for (const PointingDeviceType& input_device : input_devices) {
    if (input_device.type == ui::INPUT_DEVICE_INTERNAL) {
      out_has_internal_pointing_device = true;
    } else if (input_device.type == ui::INPUT_DEVICE_USB ||
               (input_device.type == ui::INPUT_DEVICE_BLUETOOTH &&
                bluetooth_device_observer->IsConnectedBluetoothDevice(
                    input_device))) {
      out_has_external_pointing_device = true;
    }
    if (out_has_external_pointing_device && out_has_internal_pointing_device) {
      return;
    }
  }
}

// The default behavior in Clamshell mode.
constexpr TabletModeController::TabletModeBehavior kDefault{};

// Defines the behavior of the tablet mode when enabled by sensor.
constexpr TabletModeController::TabletModeBehavior kOnBySensor{
    .block_internal_input_device = true,
};

// Defines the behavior that sticks to tablet mode. Used to implement the
// --force-tablet-mode=touch_view flag.
constexpr TabletModeController::TabletModeBehavior kLockInTabletMode{
    .use_sensor = false,
    .observe_display_events = false,
    .observe_pointer_device_events = false,
    .always_show_overview_button = true,
};

// Defines the behavior that sticks to tablet mode. Used to implement the
// --force-tablet-mode=clamshell flag.
constexpr TabletModeController::TabletModeBehavior kLockInClamshellMode{
    .use_sensor = false,
    .observe_display_events = false,
    .observe_pointer_device_events = false,
};

// Defines the behavior used for testing. It prevents the device from
// switching the mode due to sensor events during the test.
constexpr TabletModeController::TabletModeBehavior kOnForTest{
    .use_sensor = false,
    .block_internal_input_device = true,
    .force_physical_tablet_state =
        TabletModeController::ForcePhysicalTabletState::kForceTabletMode,
};

// Used for the testing API to forcibly enter into the tablet mode. It should
// not observe hardware events as tests want to stick with the tablet mode, and
// it should not block internal keyboard as some tests may want to use keyboard
// events in the tablet mode.
constexpr TabletModeController::TabletModeBehavior kOnForAutotest{
    .use_sensor = false,
    .observe_display_events = false,
    .observe_pointer_device_events = false,
    .force_physical_tablet_state =
        TabletModeController::ForcePhysicalTabletState::kForceTabletMode,
};

// Used for the testing API to forcibly exit from the tablet mode.
constexpr TabletModeController::TabletModeBehavior kOffForAutotest{
    .use_sensor = false,
    .observe_display_events = false,
    .observe_pointer_device_events = false,
    .force_physical_tablet_state =
        TabletModeController::ForcePhysicalTabletState::kForceClamshellMode,
};

// Used for development purpose (currently debug shortcut shift-ctrl-alt). This
// ignores the sensor but allows to switch upon docked mode and external
// pointing device. It also forces to show the overview button.
constexpr TabletModeController::TabletModeBehavior kOnForDev{
    .use_sensor = false,
    .always_show_overview_button = true,
    .force_physical_tablet_state =
        TabletModeController::ForcePhysicalTabletState::kForceTabletMode,
};

using LidState = chromeos::PowerManagerClient::LidState;
using TabletMode = chromeos::PowerManagerClient::TabletMode;

const char* ToString(LidState lid_state) {
  switch (lid_state) {
    case LidState::OPEN:
      return "Open";
    case LidState::CLOSED:
      return "Closed";
    case LidState::NOT_PRESENT:
      return "Not present";
  }
}

const char* ToString(TabletMode tablet_mode) {
  switch (tablet_mode) {
    case TabletMode::ON:
      return "On";
    case TabletMode::OFF:
      return "Off";
    case TabletMode::UNSUPPORTED:
      return "Unsupported";
  }
}

void ReportTrasitionSmoothness(bool enter_tablet_mode, int smoothness) {
  if (enter_tablet_mode) {
    UMA_HISTOGRAM_PERCENTAGE(kTabletModeEnterHistogram, smoothness);
  } else {
    UMA_HISTOGRAM_PERCENTAGE(kTabletModeExitHistogram, smoothness);
  }
}

bool ShouldBlockUiTabletModeInKiosk() {
  return base::FeatureList::IsEnabled(kBlockUiTabletModeInKiosk);
}

}  // namespace

// An observer that observes the destruction of the |window_| and executes the
// callback. Used to run cleanup when the window is destroyed in the middle of
// certain operation.
class TabletModeController::DestroyObserver : public aura::WindowObserver {
 public:
  DestroyObserver(aura::Window* window, base::OnceCallback<void(void)> callback)
      : window_(window), callback_(std::move(callback)) {
    window_->AddObserver(this);
  }
  ~DestroyObserver() override {
    if (window_) {
      window_->RemoveObserver(this);
    }
  }

  // aura::WindowObserver:
  void OnWindowDestroying(aura::Window* window) override {
    DCHECK_EQ(window_, window);
    window_->RemoveObserver(this);
    window_ = nullptr;
    std::move(callback_).Run();
  }

  aura::Window* window() { return window_; }

 private:
  raw_ptr<aura::Window> window_;
  base::OnceCallback<void(void)> callback_;
};

// Used to hide the shelf and float containers while screenshot for tablet mode
// animation is taken.
class TabletModeController::ScopedContainerHider {
 public:
  explicit ScopedContainerHider(aura::Window* root_window)
      : root_window_(root_window) {
    DCHECK(root_window->IsRootWindow());

    ui::Layer* screen_animation_container_layer =
        root_window->GetChildById(kShellWindowId_ScreenAnimationContainer)
            ->layer();
    for (int id :
         {kShellWindowId_FloatContainer, kShellWindowId_ShelfContainer}) {
      aura::Window* container = root_window->GetChildById(id);

      std::unique_ptr<ui::LayerTreeOwner> phantom_layer =
          wm::RecreateLayers(container);
      ui::Layer* root = phantom_layer->root();
      root_window->layer()->Add(root);
      root_window->layer()->StackAbove(root, screen_animation_container_layer);
      phantom_layers_.push_back(std::move(phantom_layer));

      container->layer()->SetOpacity(0.0f);
    }
  }
  ScopedContainerHider(const ScopedContainerHider&) = delete;
  ScopedContainerHider& operator=(const ScopedContainerHider&) = delete;
  ~ScopedContainerHider() {
    // Cancel if the root window is deleted while taking a screenshot.
    if (!base::Contains(Shell::GetAllRootWindows(), root_window_)) {
      return;
    }

    for (int id :
         {kShellWindowId_FloatContainer, kShellWindowId_ShelfContainer}) {
      root_window_->GetChildById(id)->layer()->SetOpacity(1.0f);
    }
  }

 private:
  const raw_ptr<aura::Window> root_window_;

  // The layer that holds the clone of shelf and float layers while the
  // originals are hidden.
  std::vector<std::unique_ptr<ui::LayerTreeOwner>> phantom_layers_;
};

constexpr char TabletModeController::kLidAngleHistogramName[];
constexpr char TabletModeController::kTabletInactiveTimeHistogramName[];
constexpr char TabletModeController::kTabletActiveTimeHistogramName[];

////////////////////////////////////////////////////////////////////////////////
// TabletModeController, public:

// static
void TabletModeController::SetUseScreenshotForTest(bool use_screenshot) {
  use_screenshot_for_test = use_screenshot;
}

// static
ui::LayerAnimationElement::AnimatableProperty
TabletModeController::GetObservedTabletTransitionProperty() {
  return ui::LayerAnimationElement::TRANSFORM;
}

TabletModeController::TabletModeController()
    : event_blocker_(std::make_unique<InternalInputDevicesEventBlocker>()),
      tick_clock_(base::DefaultTickClock::GetInstance()) {
  Shell::Get()->AddShellObserver(this);
  base::RecordAction(base::UserMetricsAction("Touchview_Initially_Disabled"));

  // TODO(jonross): Do not create TabletModeController if the flag is
  // unavailable. This will require refactoring
  // InTabletMode to check for the existence of the
  // controller.
  if (IsBoardTypeMarkedAsTabletCapable()) {
    Shell::Get()->display_manager()->AddDisplayManagerObserver(this);
    AccelerometerReader::GetInstance()->AddObserver(this);
    ui::DeviceDataManager::GetInstance()->AddObserver(this);
    bluetooth_devices_observer_ =
        std::make_unique<BluetoothDevicesObserver>(base::BindRepeating(
            &TabletModeController::OnBluetoothAdapterOrDeviceChanged,
            base::Unretained(this)));
  }

  chromeos::PowerManagerClient* power_manager_client =
      chromeos::PowerManagerClient::Get();
  power_manager_client->AddObserver(this);
}

TabletModeController::~TabletModeController() {
  DCHECK(!tablet_mode_window_manager_);
}

void TabletModeController::Shutdown() {
  // Stop observing any animations and delete any pending screenshots.
  StopObservingAnimation(/*record_stats=*/false, /*delete_screenshot=*/true);

  if (tablet_mode_window_manager_) {
    tablet_mode_window_manager_->Shutdown(
        TabletModeWindowManager::ShutdownReason::kSystemShutdown);
  }
  tablet_mode_window_manager_.reset();

  UMA_HISTOGRAM_COUNTS_1000("Tablet.AppWindowDrag.CountOfPerUserSession",
                            app_window_drag_count_);
  UMA_HISTOGRAM_COUNTS_1000(
      "Tablet.AppWindowDrag.InSplitView.CountOfPerUserSession",
      app_window_drag_in_splitview_count_);
  UMA_HISTOGRAM_COUNTS_1000("Tablet.TabDrag.CountOfPerUserSession",
                            tab_drag_count_);
  UMA_HISTOGRAM_COUNTS_1000("Tablet.TabDrag.InSplitView.CountOfPerUserSession",
                            tab_drag_in_splitview_count_);

  Shell::Get()->RemoveShellObserver(this);

  if (IsBoardTypeMarkedAsTabletCapable()) {
    Shell::Get()->display_manager()->RemoveDisplayManagerObserver(this);
    AccelerometerReader::GetInstance()->RemoveObserver(this);
    ui::DeviceDataManager::GetInstance()->RemoveObserver(this);
  }
  chromeos::PowerManagerClient::Get()->RemoveObserver(this);

  for (auto& observer : tablet_mode_observers_) {
    observer.OnTabletControllerDestroyed();
  }
}

void TabletModeController::AddWindow(aura::Window* window) {
  if (tablet_mode_window_manager_) {
    tablet_mode_window_manager_->AddWindow(window);
  }
}

bool TabletModeController::ShouldAutoHideTitlebars(views::Widget* widget) {
  DCHECK(widget);
  if (!display::Screen::GetScreen()->InTabletMode()) {
    return false;
  }
  return widget->IsMaximized() ||
         (WindowState::Get(widget->GetNativeWindow()) &&
          WindowState::Get(widget->GetNativeWindow())->IsSnapped());
}

bool TabletModeController::AreInternalInputDeviceEventsBlocked() const {
  return event_blocker_->should_be_blocked();
}

bool TabletModeController::TriggerRecordLidAngleTimerForTesting() {
  if (!record_lid_angle_timer_.IsRunning()) {
    return false;
  }

  record_lid_angle_timer_.user_task().Run();
  return true;
}

void TabletModeController::MaybeObserveBoundsAnimation(aura::Window* window) {
  StopObservingAnimation(/*record_stats=*/false, /*delete_screenshot=*/false);

  if (!display::IsTabletStateChanging(
          display::Screen::GetScreen()->GetTabletState())) {
    return;
  }

  destroy_observer_ = std::make_unique<DestroyObserver>(
      window, base::BindOnce(&TabletModeController::StopObservingAnimation,
                             weak_factory_.GetWeakPtr(),
                             /*record_stats=*/false,
                             /*delete_screenshot=*/true));
  animating_layer_ = window->layer();
  animating_layer_->GetAnimator()->AddObserver(this);
  animating_layer_->AddObserver(this);
}

void TabletModeController::StopObservingAnimation(bool record_stats,
                                                  bool delete_screenshot) {
  StopObserving();

  ResetDestroyObserver();

  if (animating_layer_) {
    animating_layer_->GetAnimator()->StopAnimating();

    // If the observed layer is part of a cross fade animation, stopping the
    // animation will end up destroying the layer.
    if (animating_layer_) {
      animating_layer_->RemoveObserver(this);
      animating_layer_->GetAnimator()->RemoveObserver(this);
      animating_layer_ = nullptr;
    }
  }

  if (record_stats && transition_tracker_) {
    transition_tracker_->Stop();
  }
  transition_tracker_.reset();

  // Stop other animations (STEP_END), then update the tablet mode ui.
  if (tablet_mode_window_manager_ && delete_screenshot) {
    tablet_mode_window_manager_->StopWindowAnimations();
  }

  if (delete_screenshot) {
    DeleteScreenshot();
  }
}

bool TabletModeController::IsInDevTabletMode() const {
  return tablet_mode_behavior_ == kOnForDev;
}

void TabletModeController::AddObserver(TabletModeObserver* observer) {
  tablet_mode_observers_.AddObserver(observer);
}

void TabletModeController::RemoveObserver(TabletModeObserver* observer) {
  tablet_mode_observers_.RemoveObserver(observer);
}

bool TabletModeController::ForceUiTabletModeState(std::optional<bool> enabled) {
  if (!enabled.has_value()) {
    tablet_mode_behavior_ = kDefault;
  } else if (*enabled) {
    tablet_mode_behavior_ = kOnForAutotest;
  } else {
    tablet_mode_behavior_ = kOffForAutotest;
  }

  // We want to suppress the accelerometer to auto-rotate the screen based on
  // the physical orientation, as it will confuse the test scenarios. Note that
  // this should not block ScreenOrientationController as the screen may want
  // to be rotated for other factors.
  AccelerometerReader::GetInstance()->SetEnabled(!enabled.has_value());
  return SetIsInTabletPhysicalState(CalculateIsInTabletPhysicalState()) ||
         UpdateUiTabletState();
}

void TabletModeController::SetEnabledForTest(bool enabled) {
  tablet_mode_behavior_ = enabled ? kOnForTest : kDefault;

  SetIsInTabletPhysicalState(enabled);
}

void TabletModeController::OnShellInitialized() {
  forced_ui_mode_ = GetUiMode();
  switch (forced_ui_mode_) {
    case UiMode::kTabletMode:
      tablet_mode_behavior_ = kLockInTabletMode;
      UpdateUiTabletState();
      break;

    case UiMode::kClamshell:
      tablet_mode_behavior_ = kLockInClamshellMode;
      UpdateUiTabletState();
      break;

    case UiMode::kNone:
      break;
  }
}

void TabletModeController::OnDidApplyDisplayChanges() {
  if (!tablet_mode_behavior_.observe_display_events) {
    return;
  }

  // Display config changes might be due to entering or exiting docked mode, in
  // which case the availability of an active internal display changes.
  // Therefore we update the physical tablet state of the device.
  SetIsInTabletPhysicalState(CalculateIsInTabletPhysicalState());
}

void TabletModeController::OnLoginStatusChanged(LoginStatus login_status) {
  if (login_status == LoginStatus::KIOSK_APP &&
      ShouldBlockUiTabletModeInKiosk()) {
    // Tablet mode is not allowed during the kiosk session. No need to reset the
    // `forced_ui_mode_` to the previous state because on kiosk exit Chrome
    // restarts, so the `TabletModeController` will be reset.`
    // If the device is currently in the UI tablet mode, it will be forced to
    // switch to the clamshell UI mode.
    forced_ui_mode_ = UiMode::kClamshell;
    UpdateUiTabletState();
  }
}

void TabletModeController::OnChromeTerminating() {
  // The system is about to shut down, so record TabletMode usage interval
  // metrics based on whether TabletMode mode is currently active.
  RecordTabletModeUsageInterval(CurrentTabletModeIntervalType());

  // Only when |tablet_mode_usage_interval_start_time_| is not null,
  // |total_tablet_mode_time_| and |total_non_tablet_mode_time_| will have valid
  // values.
  if (!tablet_mode_usage_interval_start_time_.is_null()) {
    DCHECK(CanEnterTabletMode() && initial_input_device_set_up_finished_ &&
           have_seen_tablet_mode_event_);

    UMA_HISTOGRAM_CUSTOM_COUNTS("Ash.TouchView.TouchViewActiveTotal",
                                total_tablet_mode_time_.InMinutes(), 1,
                                base::Days(7).InMinutes(), 50);
    UMA_HISTOGRAM_CUSTOM_COUNTS("Ash.TouchView.TouchViewInactiveTotal",
                                total_non_tablet_mode_time_.InMinutes(), 1,
                                base::Days(7).InMinutes(), 50);
    base::TimeDelta total_runtime =
        total_tablet_mode_time_ + total_non_tablet_mode_time_;
    if (total_runtime.InSeconds() > 0) {
      UMA_HISTOGRAM_PERCENTAGE("Ash.TouchView.TouchViewActivePercentage",
                               100 * total_tablet_mode_time_.InSeconds() /
                                   total_runtime.InSeconds());
    }
  }
}

void TabletModeController::OnECLidAngleDriverStatusChanged(bool is_supported) {
  is_ec_lid_angle_driver_supported_ = is_supported;

  // OnECLidAngleDriverStatusChanged is guaranteed to be called before
  // OnAccelerometerUpdated. Thus calling
  // StartTrackingTabletUsageMetricsIfApplicable() before or after
  // `!is_supported` won't make any difference. The reason is that for
  // `!is_supported` case, because we haven't seen any accelerometer data yet,
  // we won't start logging here anyway.
  // OnECLidAngleDriverStatusChanged can be called before or after
  // TabletModeEventReceived. Thus we'll need the logging both here and in
  // TabletModeEventReceived function.
  StartTrackingTabletUsageMetricsIfApplicable();

  if (!is_supported) {
    return;
  }

  // When ChromeOS EC lid angle driver is supported, EC can handle lid angle
  // calculation, thus Chrome side lid angle calculation is disabled. In this
  // case, TabletModeController no longer listens to accelerometer samples.

  // Reset lid angle that might be calculated before lid angle driver is
  // read.
  lid_angle_ = 0.f;
  can_detect_lid_angle_ = false;
  if (record_lid_angle_timer_.IsRunning()) {
    record_lid_angle_timer_.Stop();
  }
  AccelerometerReader::GetInstance()->RemoveObserver(this);
}

void TabletModeController::OnAccelerometerUpdated(
    const AccelerometerUpdate& update) {
  have_seen_accelerometer_data_ = true;
  can_detect_lid_angle_ = update.has(ACCELEROMETER_SOURCE_SCREEN) &&
                          update.has(ACCELEROMETER_SOURCE_ATTACHED_KEYBOARD);
  if (!can_detect_lid_angle_) {
    if (record_lid_angle_timer_.IsRunning()) {
      record_lid_angle_timer_.Stop();
    }
  } else if (HasActiveInternalDisplay() && tablet_mode_behavior_.use_sensor) {
    // Whether or not we enter tablet mode affects whether we handle screen
    // rotation, so determine whether to enter tablet mode first.
    if (update.IsReadingStable(ACCELEROMETER_SOURCE_SCREEN) &&
        update.IsReadingStable(ACCELEROMETER_SOURCE_ATTACHED_KEYBOARD) &&
        IsAngleBetweenAccelerometerReadingsStable(update)) {
      // update.has(ACCELEROMETER_SOURCE_ATTACHED_KEYBOARD)
      // Ignore the reading if it appears unstable. The reading is considered
      // unstable if it deviates too much from gravity and/or the magnitude of
      // the reading from the lid differs too much from the reading from the
      // base.
      HandleHingeRotation(update);
    }
  }

  StartTrackingTabletUsageMetricsIfApplicable();
}

void TabletModeController::PowerManagerBecameAvailable(bool available) {
  if (!available) {
    return;
  }
  chromeos::PowerManagerClient::Get()->GetSwitchStates(base::BindOnce(
      &TabletModeController::OnGetSwitchStates, weak_factory_.GetWeakPtr()));
}

void TabletModeController::LidEventReceived(
    chromeos::PowerManagerClient::LidState state,
    base::TimeTicks time) {
  VLOG(1) << "Lid event received: " << ToString(state);
  lid_is_closed_ = state != chromeos::PowerManagerClient::LidState::OPEN;
  if (lid_is_closed_) {
    // Reset |lid_angle_| to 0.f when lid is closed. The accelerometer readings
    // can be wrong when lid is closed, e.g., it can report lid angle to be
    // around 360 degrees when lid is nearly closed.
    lid_angle_ = 0.f;
  }

  if (!tablet_mode_behavior_.use_sensor) {
    return;
  }

  SetIsInTabletPhysicalState(CalculateIsInTabletPhysicalState());
}

void TabletModeController::TabletModeEventReceived(
    chromeos::PowerManagerClient::TabletMode mode,
    base::TimeTicks time) {
  have_seen_tablet_mode_event_ = true;
  if (tablet_mode_behavior_.use_sensor) {
    VLOG(1) << "Tablet mode event received: " << ToString(mode);
    const bool on = mode == chromeos::PowerManagerClient::TabletMode::ON;

    tablet_mode_switch_is_on_ = on;
    tablet_mode_behavior_ = on ? kOnBySensor : kDefault;

    SetIsInTabletPhysicalState(CalculateIsInTabletPhysicalState());
  }

  StartTrackingTabletUsageMetricsIfApplicable();
}

void TabletModeController::SuspendImminent(
    power_manager::SuspendImminent::Reason reason) {
  // The system is about to suspend, so record TabletMode usage interval metrics
  // based on whether TabletMode mode is currently active.
  RecordTabletModeUsageInterval(CurrentTabletModeIntervalType());

  // Stop listening to any incoming input device changes during suspend as the
  // input devices may be removed during suspend and cause the device enter/exit
  // tablet mode unexpectedly.
  if (IsBoardTypeMarkedAsTabletCapable()) {
    ui::DeviceDataManager::GetInstance()->RemoveObserver(this);
    bluetooth_devices_observer_.reset();
  }
}

void TabletModeController::SuspendDone(base::TimeDelta sleep_duration) {
  // We do not want TabletMode usage metrics to include time spent in suspend.
  if (!tablet_mode_usage_interval_start_time_.is_null()) {
    tablet_mode_usage_interval_start_time_ = base::Time::Now();
  }

  // Start listening to the input device changes again.
  // It might be possible that the suspend request has been cancelled so
  // `this` was not removed as an observer of the input device changes. See
  // b/271634754 for details.
  auto* device_data_manager = ui::DeviceDataManager::GetInstance();
  if (IsBoardTypeMarkedAsTabletCapable() &&
      !device_data_manager->HasObserver(this)) {
    bluetooth_devices_observer_ =
        std::make_unique<BluetoothDevicesObserver>(base::BindRepeating(
            &TabletModeController::OnBluetoothAdapterOrDeviceChanged,
            base::Unretained(this)));
    device_data_manager->AddObserver(this);
    // Call HandlePointingDeviceAddedOrRemoved() to iterate all available input
    // devices just in case we have missed all the notifications from
    // DeviceDataManager and  BluetoothDevicesObserver when SuspendDone() is
    // called.
    HandlePointingDeviceAddedOrRemoved();
  }
}

void TabletModeController::OnInputDeviceConfigurationChanged(
    uint8_t input_device_types) {
  if (input_device_types & (ui::InputDeviceEventObserver::kMouse |
                            ui::InputDeviceEventObserver::kTouchpad |
                            ui::InputDeviceEventObserver::kPointingStick)) {
    if (input_device_types & ui::InputDeviceEventObserver::kMouse) {
      VLOG(1) << "Mouse device configuration changed.";
    }
    if (input_device_types & ui::InputDeviceEventObserver::kTouchpad) {
      VLOG(1) << "Touchpad device configuration changed.";
    }
    if (input_device_types & ui::InputDeviceEventObserver::kPointingStick) {
      VLOG(1) << "Pointing stick device configuration changed.";
    }

    HandlePointingDeviceAddedOrRemoved();
  }
}

void TabletModeController::OnDeviceListsComplete() {
  initial_input_device_set_up_finished_ = true;
  HandlePointingDeviceAddedOrRemoved();

  StartTrackingTabletUsageMetricsIfApplicable();
}

void TabletModeController::OnLayerAnimationStarted(
    ui::LayerAnimationSequence* sequence) {}

void TabletModeController::OnLayerAnimationAborted(
    ui::LayerAnimationSequence* sequence) {
  if (!transition_tracker_ || !ShouldObserveSequence(sequence)) {
    return;
  }

  StopObservingAnimation(/*record_stats=*/false, /*delete_screenshot=*/true);
}

void TabletModeController::OnLayerAnimationEnded(
    ui::LayerAnimationSequence* sequence) {
  // This may be called before |OnLayerAnimationScheduled()| if tablet is
  // entered/exited while an animation is in progress, so we won't get
  // stats/screenshot in those cases.
  // TODO(sammiequon): We may want to remove the |transition_tracker_| check and
  // simplify things since those are edge cases.
  if (!transition_tracker_ || !ShouldObserveSequence(sequence)) {
    return;
  }

  StopObservingAnimation(/*record_stats=*/true, /*delete_screenshot=*/true);
}

void TabletModeController::OnLayerAnimationScheduled(
    ui::LayerAnimationSequence* sequence) {
  if (!ShouldObserveSequence(sequence)) {
    return;
  }

  if (!transition_tracker_) {
    transition_tracker_ =
        animating_layer_->GetCompositor()->RequestNewCompositorMetricsTracker();
    transition_tracker_->Start(metrics_util::ForSmoothnessV3(
        base::BindRepeating(&ReportTrasitionSmoothness,
                            display::Screen::GetScreen()->GetTabletState() ==
                                display::TabletState::kEnteringTabletMode)));
    return;
  }

  // If another animation is scheduled while the animation we were originally
  // watching is still animating, abort and do not log stats as the stats will
  // not be accurate.
  StopObservingAnimation(/*record_stats=*/false, /*delete_screenshot=*/true);
}

void TabletModeController::LayerDestroyed(ui::Layer* layer) {
  DCHECK_EQ(animating_layer_, layer);
  animating_layer_->RemoveObserver(this);
  animating_layer_->GetAnimator()->RemoveObserver(this);
  animating_layer_ = nullptr;
}

void TabletModeController::SetEnabledForDev(bool enabled) {
  tablet_mode_behavior_ = enabled ? kOnForDev : kDefault;
  force_notify_events_blocking_changed_ = true;

  SetIsInTabletPhysicalState(enabled);
}

bool TabletModeController::ShouldShowOverviewButton() const {
  return AreInternalInputDeviceEventsBlocked() ||
         tablet_mode_behavior_.always_show_overview_button;
}

bool TabletModeController::CanEnterTabletMode() const {
  // If ChromeOS EC lid angle driver is supported, EC can handle lid angle
  // calculation, and trigger tablet mode at some point.
  // Otherwise, lid angle calculation is done on Chrome side for convertible
  // device. If we have ever seen accelerometer data, then HandleHingeRotation
  // may trigger tablet mode at some point in the future.
  return IsBoardTypeMarkedAsTabletCapable() &&
         (is_ec_lid_angle_driver_supported_.value_or(false) ||
          have_seen_accelerometer_data_);
}

////////////////////////////////////////////////////////////////////////////////
// TabletModeController, private:

void TabletModeController::SetTabletModeEnabledInternal(bool should_enable) {
  DCHECK_NE(display::Screen::GetScreen()->InTabletMode(), should_enable);

  // Hide the context menu on entering tablet mode to prevent users from
  // accessing forbidden options. Hide the context menu on exiting tablet mode
  // to match behaviors.
  HideActiveContextMenu();

  // Suspend occlusion tracker when entering or exiting tablet mode.
  SuspendOcclusionTracker();
  DeleteScreenshot();

  if (should_enable) {
    Shell::Get()->display_manager()->SetTabletState(
        display::TabletState::kEnteringTabletMode);

    // Take a screenshot if there is a top window that will get animated.
    // Floated windows will always get animated, and if the only window is a
    // floated window, we don't take a screenshot since the floated window in
    // tablet mode does not cover the whole work area.
    // TODO(sammiequon): Handle the case where the top window is not on the
    // primary display.
    aura::Window* top_window = window_util::GetTopNonFloatedWindow();
    const bool top_window_on_primary_display =
        top_window &&
        top_window->GetRootWindow() == Shell::GetPrimaryRootWindow();
    // If the top window was already animating (eg. tablet mode event received
    // while create window animation still running), skip taking the screenshot.
    // It will take a performance hit but will remove cases where the screenshot
    // might not get deleted because of the extra animation observer methods
    // getting fired.
    const bool top_window_animating =
        top_window && top_window->layer()->GetAnimator()->is_animating();
    // We'll keep overview active after clamshell <-> tablet mode transition if
    // it was active before transition, do not take screenshot if overview is
    // active in this case.
    const bool overview_remain_active =
        Shell::Get()->overview_controller()->InOverviewSession();
    if (use_screenshot_for_test && top_window_on_primary_display &&
        !top_window_animating && !overview_remain_active) {
      TakeScreenshot(top_window);
    } else {
      FinishInitTabletMode();
    }
  } else {
    // We may have entered tablet mode, then tried to exit before the screenshot
    // was taken. In this case `tablet_mode_window_manager_` will be null.
    if (tablet_mode_window_manager_) {
      tablet_mode_window_manager_->SetIgnoreWmEventsForExit();
    }

    Shell::Get()->display_manager()->SetTabletState(
        display::TabletState::kExitingTabletMode);

    // Many events can lead to shelf config updates as a result of
    // kInClamshellMode event. Update the shelf config during "ending"
    // stage rather than the "ended", so `in_tablet_mode_` gets updated
    // correctly, and the shelf bounds are stabilized early so as not to have
    // multiple unnecessary work-area bounds changes.
    ShelfConfig::Get()->UpdateForTabletMode(/*in_tablet_mode=*/false);

    if (tablet_mode_window_manager_) {
      tablet_mode_window_manager_->Shutdown(
          TabletModeWindowManager::ShutdownReason::kExitTabletUIMode);
    }
    tablet_mode_window_manager_.reset();

    base::RecordAction(base::UserMetricsAction("Touchview_Disabled"));
    RecordTabletModeUsageInterval(TABLET_MODE_INTERVAL_ACTIVE);
    Shell::Get()->display_manager()->SetTabletState(
        display::TabletState::kInClamshellMode);
    VLOG(1) << "Exit tablet mode.";

    UpdateInternalInputDevicesEventBlocker();
    Shell::Get()->cursor_manager()->ShowCursor();
  }
}

void TabletModeController::HandleHingeRotation(
    const AccelerometerUpdate& update) {
  static const gfx::Vector3dF hinge_vector(1.0f, 0.0f, 0.0f);
  gfx::Vector3dF base_reading =
      update.GetVector(ACCELEROMETER_SOURCE_ATTACHED_KEYBOARD);
  gfx::Vector3dF lid_reading = update.GetVector(ACCELEROMETER_SOURCE_SCREEN);

  // As the hinge approaches a vertical angle, the base and lid accelerometers
  // approach the same values making any angle calculations highly inaccurate.
  // Smooth out instantaneous acceleration when nearly vertical to increase
  // accuracy.
  float largest_hinge_acceleration =
      std::max(std::abs(base_reading.x()), std::abs(lid_reading.x()));
  float smoothing_ratio = std::clamp(
      (largest_hinge_acceleration - kHingeVerticalSmoothingStart) /
          (kHingeVerticalSmoothingMaximum - kHingeVerticalSmoothingStart),
      0.0f, 1.0f);

  // We cannot trust the computed lid angle when the device is held vertically.
  bool is_angle_reliable =
      largest_hinge_acceleration <= kHingeVerticalSmoothingMaximum;

  base_smoothed_.Scale(smoothing_ratio);
  base_reading.Scale(1.0f - smoothing_ratio);
  base_smoothed_.Add(base_reading);

  lid_smoothed_.Scale(smoothing_ratio);
  lid_reading.Scale(1.0f - smoothing_ratio);
  lid_smoothed_.Add(lid_reading);

  if (tablet_mode_switch_is_on_) {
    return;
  }

  // Do not calculate lid angle when lid is closed to prevent the device
  // accidentally entering tablet mode. The angle calculated when lid is closed
  // is not accurate (the angle between the base and the lid might be a minus
  // value when lid is closed, and since we do adjustment for minus values, the
  // angle might be in the same range as tablet mode angle range).
  if (lid_is_closed_) {
    return;
  }

  // Ignore the component of acceleration parallel to the hinge for the purposes
  // of hinge angle calculation.
  gfx::Vector3dF base_flattened(base_smoothed_);
  gfx::Vector3dF lid_flattened(lid_smoothed_);
  base_flattened.set_x(0.0f);
  lid_flattened.set_x(0.0f);

  // Compute the angle between the base and the lid.
  lid_angle_ = 180.0f - gfx::ClockwiseAngleBetweenVectorsInDegrees(
                            base_flattened, lid_flattened, hinge_vector);
  if (lid_angle_ < 0.0f) {
    lid_angle_ += 360.0f;
  }

  lid_angle_is_stable_ = is_angle_reliable && lid_angle_ >= kMinStableAngle &&
                         lid_angle_ <= kMaxStableAngle;

  if (lid_angle_is_stable_) {
    // Reset the timestamp of first unstable lid angle because we get a stable
    // reading.
    first_unstable_lid_angle_time_ = base::TimeTicks();
  } else if (first_unstable_lid_angle_time_.is_null()) {
    first_unstable_lid_angle_time_ = tick_clock_->NowTicks();
  }

  const bool new_tablet_physical_state = CalculateIsInTabletPhysicalState();
  tablet_mode_behavior_ = new_tablet_physical_state ? kOnBySensor : kDefault;
  SetIsInTabletPhysicalState(new_tablet_physical_state);

  // Start reporting the lid angle if we aren't already doing so.
  if (!record_lid_angle_timer_.IsRunning()) {
    record_lid_angle_timer_.Start(
        FROM_HERE, kRecordLidAngleInterval,
        base::BindRepeating(&TabletModeController::RecordLidAngle,
                            base::Unretained(this)));
  }
}

void TabletModeController::OnGetSwitchStates(
    std::optional<chromeos::PowerManagerClient::SwitchStates> result) {
  if (!result.has_value()) {
    return;
  }

  LidEventReceived(result->lid_state, base::TimeTicks::Now());
  TabletModeEventReceived(result->tablet_mode, base::TimeTicks::Now());
}

bool TabletModeController::CanUseUnstableLidAngle() const {
  DCHECK(!first_unstable_lid_angle_time_.is_null());

  const base::TimeTicks now = tick_clock_->NowTicks();
  DCHECK(now >= first_unstable_lid_angle_time_);
  const base::TimeDelta elapsed_time = now - first_unstable_lid_angle_time_;
  return elapsed_time >= kUnstableLidAngleDuration;
}

void TabletModeController::RecordTabletModeUsageInterval(
    TabletModeIntervalType type) {
  // If |tablet_mode_usage_interval_start_time_| is null, do not record any
  // tablet mode usage metrics. It may happen when we have some false positive
  // tablet mode activations during startup.
  if (tablet_mode_usage_interval_start_time_.is_null()) {
    return;
  }

  DCHECK(CanEnterTabletMode() && initial_input_device_set_up_finished_ &&
         have_seen_tablet_mode_event_);

  base::Time current_time = base::Time::Now();
  base::TimeDelta delta = current_time - tablet_mode_usage_interval_start_time_;
  switch (type) {
    case TABLET_MODE_INTERVAL_INACTIVE:
      UMA_HISTOGRAM_LONG_TIMES(kTabletInactiveTimeHistogramName, delta);
      total_non_tablet_mode_time_ += delta;
      break;
    case TABLET_MODE_INTERVAL_ACTIVE:
      UMA_HISTOGRAM_LONG_TIMES(kTabletActiveTimeHistogramName, delta);
      total_tablet_mode_time_ += delta;
      break;
  }

  tablet_mode_usage_interval_start_time_ = current_time;
}

void TabletModeController::RecordLidAngle() {
  DCHECK(can_detect_lid_angle_);
  base::LinearHistogram::FactoryGet(
      kLidAngleHistogramName, /*minimum=*/1, /*maximum=*/360,
      /*bucket_count=*/50, base::HistogramBase::kUmaTargetedHistogramFlag)
      ->Add(std::round(lid_angle_));
}

TabletModeController::TabletModeIntervalType
TabletModeController::CurrentTabletModeIntervalType() {
  return display::Screen::GetScreen()->InTabletMode()
             ? TABLET_MODE_INTERVAL_ACTIVE
             : TABLET_MODE_INTERVAL_INACTIVE;
}

void TabletModeController::HandlePointingDeviceAddedOrRemoved() {
  if (!initial_input_device_set_up_finished_) {
    return;
  }

  bool has_external_pointing_device = false;
  bool has_internal_pointing_device = false;

  // Check if there is an external and internal mouse or touchpad device.
  CheckHasPointingDevices(
      ui::DeviceDataManager::GetInstance()->GetMouseDevices(),
      bluetooth_devices_observer_.get(), has_external_pointing_device,
      has_internal_pointing_device);
  if (!has_external_pointing_device || !has_internal_pointing_device) {
    CheckHasPointingDevices(
        ui::DeviceDataManager::GetInstance()->GetTouchpadDevices(),
        bluetooth_devices_observer_.get(), has_external_pointing_device,
        has_internal_pointing_device);
  }
  if (!has_external_pointing_device || !has_internal_pointing_device) {
    CheckHasPointingDevices(
        ui::DeviceDataManager::GetInstance()->GetPointingStickDevices(),
        bluetooth_devices_observer_.get(), has_external_pointing_device,
        has_internal_pointing_device);
  }

  const bool changed =
      (has_external_pointing_device_ != has_external_pointing_device) ||
      (has_internal_pointing_device_ != has_internal_pointing_device);

  if (!changed) {
    return;
  }

  has_external_pointing_device_ = has_external_pointing_device;
  has_internal_pointing_device_ = has_internal_pointing_device;

  // We only need to update UI state if observed internal pointing device or
  // external pointing device changed.
  if (tablet_mode_behavior_.observe_pointer_device_events) {
    UpdateUiTabletState();
  }
}

void TabletModeController::OnBluetoothAdapterOrDeviceChanged(
    device::BluetoothDevice* device) {
  // We only care about pointing type bluetooth device change. Note KEYBOARD
  // type is also included here as sometimes a bluetooth keyboard comes with a
  // touch pad.
  if (!device ||
      device->GetDeviceType() == device::BluetoothDeviceType::MOUSE ||
      device->GetDeviceType() ==
          device::BluetoothDeviceType::KEYBOARD_MOUSE_COMBO ||
      device->GetDeviceType() == device::BluetoothDeviceType::KEYBOARD ||
      device->GetDeviceType() == device::BluetoothDeviceType::TABLET) {
    VLOG(1) << "Bluetooth device configuration changed.";
    HandlePointingDeviceAddedOrRemoved();
  }
}

void TabletModeController::UpdateInternalInputDevicesEventBlocker() {
  // Internal input devices should be blocked (as long as the current
  // tablet_mode_behavior_ allows it) if we're in UI tablet mode, or if the
  // device is in physical tablet state.
  // Note that |is_in_tablet_physical_state_| takes into account whether the
  // device is in docked mode (with no active internal display), in which case
  // internal input devices should NOT be blocked, since the user may still want
  // to use the internal keyboard and mouse in docked mode. This can happen if
  // the user turns off the internal display without closing the lid by means of
  // setting the brightness to 0.
  const bool should_block_internal_events =
      tablet_mode_behavior_.block_internal_input_device &&
      (display::Screen::GetScreen()->InTabletMode() ||
       is_in_tablet_physical_state_);

  if (should_block_internal_events == AreInternalInputDeviceEventsBlocked()) {
    if (force_notify_events_blocking_changed_) {
      for (auto& observer : tablet_mode_observers_) {
        observer.OnTabletModeEventsBlockingChanged();
      }
      force_notify_events_blocking_changed_ = false;
    }

    return;
  }

  event_blocker_->UpdateInternalInputDevices(should_block_internal_events);
  for (auto& observer : tablet_mode_observers_) {
    observer.OnTabletModeEventsBlockingChanged();
  }
}

void TabletModeController::SuspendOcclusionTracker() {
  occlusion_tracker_reset_timer_.Stop();
  occlusion_tracker_pauser_ =
      std::make_unique<aura::WindowOcclusionTracker::ScopedPause>();
  occlusion_tracker_reset_timer_.Start(FROM_HERE, kOcclusionTrackerTimeout,
                                       this,
                                       &TabletModeController::ResetPauser);
}

void TabletModeController::ResetPauser() {
  occlusion_tracker_pauser_.reset();
}

void TabletModeController::FinishInitTabletMode() {
  DCHECK_EQ(display::TabletState::kEnteringTabletMode,
            display::Screen::GetScreen()->GetTabletState());

  // Transition shelf to tablet mode state, now that the screenshot for tablet
  // mode transition was taken. Taking screenshot recreates shelf container
  // layer, and uses the original layer - changing shelf state before the
  // screenshot is taken would change the shelf appearance, and could cause
  // issues where the original shelf widget layer is not re-painted correctly in
  // response to a paint schedule for tablet mode state change.
  // Update the shelf state befire initiating tablet mode window state changes
  // to avoid negative impact of window work-area changes (due to changes in
  // shelf bounds) during window state transition on the animation smoothness
  // https://crbug.com/1044316.
  ShelfConfig::Get()->UpdateForTabletMode(/*in_tablet_mode=*/true);

  tablet_mode_window_manager_ = std::make_unique<TabletModeWindowManager>();
  tablet_mode_window_manager_->Init();

  base::RecordAction(base::UserMetricsAction("Touchview_Enabled"));
  RecordTabletModeUsageInterval(TABLET_MODE_INTERVAL_INACTIVE);
  Shell::Get()->display_manager()->SetTabletState(
      display::TabletState::kInTabletMode);

  // In some cases, TabletModeWindowManager::TabletModeWindowManager uses
  // split view to represent windows that were snapped in desktop mode. If
  // there is a window snapped on one side but no window snapped on the other
  // side, then overview mode should be started (to be seen on the side with
  // no snapped window).
  const auto state =
      SplitViewController::Get(Shell::GetPrimaryRootWindow())->state();
  if (state == SplitViewController::State::kPrimarySnapped ||
      state == SplitViewController::State::kSecondarySnapped) {
    Shell::Get()->overview_controller()->StartOverview(
        OverviewStartAction::kSplitView);
  }

  UpdateInternalInputDevicesEventBlocker();
  Shell::Get()->cursor_manager()->HideCursor();

  VLOG(1) << "Enter tablet mode.";
}

void TabletModeController::DeleteScreenshot() {
  if (screenshot_layer_) {
    VLOG(1) << "Tablet screenshot layer destroyed.";
  }

  screenshot_layer_.reset();
  screenshot_taken_callback_.Cancel();
  screenshot_set_callback_.Cancel();
  ResetDestroyObserver();
  container_hider_.reset();
}

void TabletModeController::ResetDestroyObserver() {
  destroy_observer_.reset();
}

void TabletModeController::TakeScreenshot(aura::Window* top_window) {
  DCHECK(!top_window->IsRootWindow());
  destroy_observer_ = std::make_unique<DestroyObserver>(
      top_window, base::BindOnce(&TabletModeController::ResetDestroyObserver,
                                 weak_factory_.GetWeakPtr()));
  screenshot_set_callback_.Reset(base::BindOnce(
      &TabletModeController::FinishInitTabletMode, weak_factory_.GetWeakPtr()));

  auto* screenshot_window = top_window->GetRootWindow()->GetChildById(
      kShellWindowId_ScreenAnimationContainer);
  base::OnceClosure callback = screenshot_set_callback_.callback();

  aura::Window* root_window = top_window->GetRootWindow();
  container_hider_ = std::make_unique<ScopedContainerHider>(root_window);

  // Request a screenshot.
  screenshot_taken_callback_.Reset(base::BindOnce(
      &TabletModeController::OnLayerCopyed, weak_factory_.GetWeakPtr(),
      std::move(callback), root_window));

  CopyLayerContentToNewLayer(screenshot_window->layer(),
                             screenshot_taken_callback_.callback());

  VLOG(1) << "Tablet screenshot requested.";
}

void TabletModeController::OnLayerCopyed(
    base::OnceClosure on_screenshot_taken,
    aura::Window* root_window,
    std::unique_ptr<ui::Layer> copy_layer) {
  aura::Window* top_window =
      destroy_observer_ ? destroy_observer_->window() : nullptr;
  ResetDestroyObserver();

  container_hider_.reset();

  // Cancel if the root window is deleted while taking a screenshot.
  if (!base::Contains(Shell::GetAllRootWindows(), root_window)) {
    return;
  }

  if (!copy_layer || !top_window) {
    std::move(on_screenshot_taken).Run();
    return;
  }

  // Stack the screenshot under |top_window|, to fully occlude all windows
  // except |top_window| for the duration of the enter tablet mode animation.
  screenshot_layer_ = std::move(copy_layer);
  top_window->parent()->layer()->Add(screenshot_layer_.get());
  screenshot_layer_->SetBounds(top_window->GetRootWindow()->bounds());
  top_window->parent()->layer()->StackBelow(screenshot_layer_.get(),
                                            top_window->layer());

  std::move(on_screenshot_taken).Run();

  VLOG(1) << "Tablet screenshot layer created.";
}

bool TabletModeController::CalculateIsInTabletPhysicalState() const {
  switch (tablet_mode_behavior_.force_physical_tablet_state) {
    case ForcePhysicalTabletState::kDefault:
      // Don't return forced result. Check the hardware configuration.
      break;
    case ForcePhysicalTabletState::kForceTabletMode:
      return true;
    case ForcePhysicalTabletState::kForceClamshellMode:
      return false;
  }

  if (!HasActiveInternalDisplay()) {
    return false;
  }

  // For updated EC, the tablet mode switch activates at 200 degrees, and
  // deactivates at 160 degrees.
  // For old EC, the tablet mode switch activates at 300 degrees, so it's
  // always reliable when |tablet_mode_switch_is_on_|.
  if (tablet_mode_switch_is_on_) {
    return true;
  }

  if (lid_is_closed_) {
    return false;
  }

  if (!can_detect_lid_angle_) {
    return false;
  }

  // Toggle tablet mode on or off when corresponding thresholds are passed.
  if (lid_angle_ >= kEnterTabletModeAngle &&
      (lid_angle_is_stable_ || CanUseUnstableLidAngle())) {
    return true;
  }

  if (lid_angle_ <= kExitTabletModeAngle && lid_angle_is_stable_) {
    // For angles that are in the exit range, we only consider the stable ones,
    // (i.e. we don't check `CanUseUnstableLidAngle()`) in order to avoid
    // changing the mode when the lid is almost closed, or recently opened.
    return false;
  }

  // The state should remain the same.
  return is_in_tablet_physical_state_;
}

bool TabletModeController::ShouldUiBeInTabletMode() const {
  if (forced_ui_mode_ == UiMode::kTabletMode) {
    return true;
  }

  if (forced_ui_mode_ == UiMode::kClamshell) {
    return false;
  }

  if (!tablet_mode_behavior_.observe_pointer_device_events) {
    return is_in_tablet_physical_state_;
  }

  // If this is a tablet capable device, and `OnDeviceListsComplete()` has
  // not been received yet, then skip further checking and don't enter tablet
  // mode, since `has_external_pointing_device_` and
  // `has_internal_pointing_device_` are not accurate yet.
  if (IsBoardTypeMarkedAsTabletCapable() &&
      !initial_input_device_set_up_finished_) {
    return false;
  }

  if (has_external_pointing_device_) {
    return false;
  }

  if (is_in_tablet_physical_state_) {
    return true;
  }

  return !has_internal_pointing_device_ && CanEnterTabletMode() &&
         HasActiveInternalDisplay() && base::SysInfo::IsRunningOnChromeOS();
}

bool TabletModeController::SetIsInTabletPhysicalState(bool new_state) {
  if (new_state == is_in_tablet_physical_state_) {
    return false;
  }

  is_in_tablet_physical_state_ = new_state;

  for (auto& observer : tablet_mode_observers_) {
    observer.OnTabletPhysicalStateChanged();
  }

  // InputDeviceBlocker must always be updated, but don't update it here if the
  // UI state has changed because it's already done.
  if (UpdateUiTabletState()) {
    return true;
  }

  UpdateInternalInputDevicesEventBlocker();
  return false;
}

bool TabletModeController::UpdateUiTabletState() {
  const bool should_be_in_tablet_mode = ShouldUiBeInTabletMode();
  if (should_be_in_tablet_mode ==
      display::Screen::GetScreen()->InTabletMode()) {
    return false;
  }

  SetTabletModeEnabledInternal(should_be_in_tablet_mode);
  Shell::Get()
      ->accessibility_controller()
      ->TriggerAccessibilityAlertWithMessage(l10n_util::GetStringUTF8(
          should_be_in_tablet_mode ? IDS_ASH_SWITCH_TO_TABLET_MODE
                                   : IDS_ASH_SWITCH_TO_LAPTOP_MODE));
  return true;
}

void TabletModeController::StartTrackingTabletUsageMetricsIfApplicable() {
  if (!CanEnterTabletMode() || !initial_input_device_set_up_finished_ ||
      !have_seen_tablet_mode_event_ ||
      !tablet_mode_usage_interval_start_time_.is_null()) {
    return;
  }

  tablet_mode_usage_interval_start_time_ = base::Time::Now();
}

}  // namespace ash