ash / shelf / shelf.cc [blame]

// Copyright 2016 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/shelf/shelf.h"

#include <memory>

#include "ash/animation/animation_change_type.h"
#include "ash/app_list/app_list_controller_impl.h"
#include "ash/constants/ash_constants.h"
#include "ash/constants/ash_features.h"
#include "ash/constants/ash_switches.h"
#include "ash/metrics/login_unlock_throughput_recorder.h"
#include "ash/public/cpp/keyboard/keyboard_controller_observer.h"
#include "ash/public/cpp/shelf_item_delegate.h"
#include "ash/public/cpp/shelf_model.h"
#include "ash/public/cpp/shelf_types.h"
#include "ash/public/cpp/shell_window_ids.h"
#include "ash/root_window_controller.h"
#include "ash/shelf/desk_button_widget.h"
#include "ash/shelf/hotseat_widget.h"
#include "ash/shelf/login_shelf_widget.h"
#include "ash/shelf/scrollable_shelf_view.h"
#include "ash/shelf/shelf_controller.h"
#include "ash/shelf/shelf_focus_cycler.h"
#include "ash/shelf/shelf_layout_manager.h"
#include "ash/shelf/shelf_layout_manager_observer.h"
#include "ash/shelf/shelf_navigation_widget.h"
#include "ash/shelf/shelf_observer.h"
#include "ash/shelf/shelf_tooltip_manager.h"
#include "ash/shelf/shelf_widget.h"
#include "ash/shell.h"
#include "ash/system/status_area_widget.h"
#include "ash/wm/work_area_insets.h"
#include "base/check.h"
#include "base/functional/bind.h"
#include "base/functional/callback_helpers.h"
#include "base/i18n/rtl.h"
#include "base/memory/raw_ptr.h"
#include "base/memory/weak_ptr.h"
#include "base/metrics/histogram_macros.h"
#include "base/notreached.h"
#include "ui/display/types/display_constants.h"
#include "ui/gfx/geometry/rect.h"

namespace ash {

namespace {

bool IsAppListBackground(ShelfBackgroundType background_type) {
  switch (background_type) {
    case ShelfBackgroundType::kHomeLauncher:
      return true;
    case ShelfBackgroundType::kDefaultBg:
    case ShelfBackgroundType::kMaximized:
    case ShelfBackgroundType::kOobe:
    case ShelfBackgroundType::kLogin:
    case ShelfBackgroundType::kLoginNonBlurredWallpaper:
    case ShelfBackgroundType::kOverview:
    case ShelfBackgroundType::kInApp:
      return false;
  }
}

bool IsBottomAlignment(ShelfAlignment alignment) {
  return alignment == ShelfAlignment::kBottom ||
         alignment == ShelfAlignment::kBottomLocked;
}

}  // namespace

// Records smoothness of bounds animations for the HotseatWidget.
class HotseatWidgetAnimationMetricsReporter {
 public:
  // The different kinds of hotseat elements.
  enum class HotseatElementType {
    // The Hotseat Widget.
    kWidget,
    // The Hotseat Widget's translucent background.
    kTranslucentBackground
  };

  explicit HotseatWidgetAnimationMetricsReporter(
      HotseatElementType hotseat_element)
      : hotseat_element_(hotseat_element) {}
  ~HotseatWidgetAnimationMetricsReporter() = default;

  void ReportSmoothness(HotseatState target_state, int smoothness) {
    switch (target_state) {
      case HotseatState::kShownClamshell:
      case HotseatState::kShownHomeLauncher:
        if (hotseat_element_ == HotseatElementType::kWidget) {
          UMA_HISTOGRAM_PERCENTAGE(
              "Ash.HotseatWidgetAnimation.Widget.AnimationSmoothness."
              "TransitionToShownHotseat",
              smoothness);
        } else {
          UMA_HISTOGRAM_PERCENTAGE(
              "Ash.HotseatWidgetAnimation.TranslucentBackground."
              "AnimationSmoothness.TransitionToShownHotseat",
              smoothness);
        }
        break;
      case HotseatState::kExtended:
        if (hotseat_element_ == HotseatElementType::kWidget) {
          UMA_HISTOGRAM_PERCENTAGE(
              "Ash.HotseatWidgetAnimation.Widget.AnimationSmoothness."
              "TransitionToExtendedHotseat",
              smoothness);
        } else {
          UMA_HISTOGRAM_PERCENTAGE(
              "Ash.HotseatWidgetAnimation.TranslucentBackground."
              "AnimationSmoothness.TransitionToExtendedHotseat",
              smoothness);
        }
        break;
      case HotseatState::kHidden:
        if (hotseat_element_ == HotseatElementType::kWidget) {
          UMA_HISTOGRAM_PERCENTAGE(
              "Ash.HotseatWidgetAnimation.Widget.AnimationSmoothness."
              "TransitionToHiddenHotseat",
              smoothness);
        } else {
          UMA_HISTOGRAM_PERCENTAGE(
              "Ash.HotseatWidgetAnimation.TranslucentBackground."
              "AnimationSmoothness.TransitionToHiddenHotseat",
              smoothness);
        }
        break;
      case HotseatState::kNone:
        NOTREACHED();
    }
  }

  metrics_util::ReportCallback GetReportCallback(HotseatState target_state) {
    DCHECK_NE(target_state, HotseatState::kNone);
    return metrics_util::ForSmoothnessV3(base::BindRepeating(
        &HotseatWidgetAnimationMetricsReporter::ReportSmoothness,
        weak_ptr_factory_.GetWeakPtr(), target_state));
  }

 private:
  // The element that is reporting an animation.
  const HotseatElementType hotseat_element_;

  base::WeakPtrFactory<HotseatWidgetAnimationMetricsReporter> weak_ptr_factory_{
      this};
};

// An animation metrics reporter for the shelf navigation widget.
class ASH_EXPORT NavigationWidgetAnimationMetricsReporter {
 public:
  NavigationWidgetAnimationMetricsReporter() = default;

  ~NavigationWidgetAnimationMetricsReporter() = default;

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

  void ReportSmoothness(HotseatState target_hotseat_state, int smoothness) {
    switch (target_hotseat_state) {
      case HotseatState::kShownClamshell:
      case HotseatState::kShownHomeLauncher:
        UMA_HISTOGRAM_PERCENTAGE(
            "Ash.NavigationWidget.Widget.AnimationSmoothness."
            "TransitionToShownHotseat",
            smoothness);
        break;
      case HotseatState::kExtended:
        UMA_HISTOGRAM_PERCENTAGE(
            "Ash.NavigationWidget.Widget.AnimationSmoothness."
            "TransitionToExtendedHotseat",
            smoothness);
        break;
      case HotseatState::kHidden:
        UMA_HISTOGRAM_PERCENTAGE(
            "Ash.NavigationWidget.Widget.AnimationSmoothness."
            "TransitionToHiddenHotseat",
            smoothness);
        break;
      case HotseatState::kNone:
        NOTREACHED();
    }
  }

  metrics_util::ReportCallback GetReportCallback(
      HotseatState target_hotseat_state) {
    DCHECK_NE(target_hotseat_state, HotseatState::kNone);
    return metrics_util::ForSmoothnessV3(base::BindRepeating(
        &NavigationWidgetAnimationMetricsReporter::ReportSmoothness,
        weak_ptr_factory_.GetWeakPtr(), target_hotseat_state));
  }

 private:
  base::WeakPtrFactory<NavigationWidgetAnimationMetricsReporter>
      weak_ptr_factory_{this};
};

// Shelf::AutoHideEventHandler -----------------------------------------------

// Forwards mouse and gesture events to ShelfLayoutManager for auto-hide.
class Shelf::AutoHideEventHandler : public ui::EventHandler {
 public:
  explicit AutoHideEventHandler(Shelf* shelf) : shelf_(shelf) {
    Shell::Get()->AddPreTargetHandler(this);
  }

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

  ~AutoHideEventHandler() override {
    Shell::Get()->RemovePreTargetHandler(this);
  }

  // ui::EventHandler:
  void OnMouseEvent(ui::MouseEvent* event) override {
    shelf_->shelf_layout_manager()->UpdateAutoHideForMouseEvent(
        event, static_cast<aura::Window*>(event->target()));
  }
  void OnGestureEvent(ui::GestureEvent* event) override {
    shelf_->shelf_layout_manager()->ProcessGestureEventOfAutoHideShelf(
        event, static_cast<aura::Window*>(event->target()));
  }
  void OnTouchEvent(ui::TouchEvent* event) override {
    if (shelf_->auto_hide_behavior() != ShelfAutoHideBehavior::kAlways)
      return;

    // The event target should be the shelf widget or the hotseat widget.
    if (!shelf_->shelf_layout_manager()->IsShelfWindow(
            static_cast<aura::Window*>(event->target()))) {
      return;
    }

    // The touch-pressing event may hide the shelf. Lock the shelf's auto hide
    // state to give the shelf a chance to handle the touch event before it
    // being hidden.
    ShelfLayoutManager* shelf_layout_manager = shelf_->shelf_layout_manager();
    if (event->type() == ui::EventType::kTouchPressed && shelf_->IsVisible()) {
      shelf_layout_manager->LockAutoHideState(true);
    } else if (event->type() == ui::EventType::kTouchReleased ||
               event->type() == ui::EventType::kTouchCancelled) {
      // Unlock auto hide (and eventually recompute auto hide state).
      shelf_layout_manager->LockAutoHideState(false);
    }
  }

 private:
  raw_ptr<Shelf> shelf_;
};

// Shelf::AutoDimEventHandler -----------------------------------------------

// Handles mouse and touch events and determines whether ShelfLayoutManager
// should update shelf opacity for auto-dimming.
class Shelf::AutoDimEventHandler : public ui::EventHandler,
                                   public ShelfObserver {
 public:
  explicit AutoDimEventHandler(Shelf* shelf) : shelf_(shelf) {
    Shell::Get()->AddPreTargetHandler(this);
    shelf_observation_.Observe(shelf_.get());
    UndimShelf();
  }

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

  ~AutoDimEventHandler() override {
    Shell::Get()->RemovePreTargetHandler(this);
  }

  // ui::EventHandler:
  void OnMouseEvent(ui::MouseEvent* event) override {
    if (shelf_->shelf_layout_manager()->IsShelfWindow(
            static_cast<aura::Window*>(event->target()))) {
      UndimShelf();
    }
  }

  void OnTouchEvent(ui::TouchEvent* event) override {
    if (shelf_->shelf_layout_manager()->IsShelfWindow(
            static_cast<aura::Window*>(event->target()))) {
      UndimShelf();
    }
  }

  void StartDimShelfTimer() {
    dim_shelf_timer_.Start(
        FROM_HERE, kDimDelay,
        base::BindOnce(&AutoDimEventHandler::DimShelf, base::Unretained(this)));
  }

  void DimShelf() {
    // Attempt to dim the shelf. Stop the |dim_shelf_timer_| if successful.
    if (shelf_->shelf_layout_manager()->SetDimmed(true))
      dim_shelf_timer_.Stop();
  }

  // Sets shelf as active and sets timer to mark shelf as inactive.
  void UndimShelf() {
    shelf_->shelf_layout_manager()->SetDimmed(false);
    StartDimShelfTimer();
  }

  bool HasDimShelfTimer() { return dim_shelf_timer_.IsRunning(); }

  // ShelfObserver:
  void OnAutoHideStateChanged(ShelfAutoHideState new_state) override {
    // Shelf should be undimmed when it is shown.
    if (new_state == ShelfAutoHideState::SHELF_AUTO_HIDE_SHOWN)
      UndimShelf();
  }

  // ShelfObserver:
  void OnShelfVisibilityStateChanged(ShelfVisibilityState new_state) override {
    // Shelf should be undimmed when it is shown.
    if (new_state != ShelfVisibilityState::SHELF_HIDDEN)
      UndimShelf();
  }

 private:
  // Unowned pointer to the shelf that owns this event handler.
  raw_ptr<Shelf> shelf_;
  // OneShotTimer that dims shelf due to inactivity.
  base::OneShotTimer dim_shelf_timer_;
  // An observer that notifies the AutoDimHandler that shelf visibility has
  // changed.
  base::ScopedObservation<Shelf, ShelfObserver> shelf_observation_{this};

  // Delay before dimming the shelf.
  const base::TimeDelta kDimDelay = base::Seconds(5);
};

// Shelf::ScopedDisableAutoHide ----------------------------------------------

Shelf::ScopedDisableAutoHide::ScopedDisableAutoHide(Shelf* shelf)
    : shelf_(shelf->GetWeakPtr()) {
  CHECK(shelf);

  ++shelf_->disable_auto_hide_;
  if (shelf_->disable_auto_hide_ == 1) {
    shelf_->UpdateVisibilityState();
  }
}

Shelf::ScopedDisableAutoHide::~ScopedDisableAutoHide() {
  if (!shelf_) {
    return;
  }

  --shelf_->disable_auto_hide_;
  CHECK_GE(shelf_->disable_auto_hide_, 0);
  if (shelf_->disable_auto_hide_ == 0) {
    shelf_->UpdateVisibilityState();
  }
}

// Shelf ---------------------------------------------------------------------

Shelf::Shelf()
    : shelf_locking_manager_(this),
      shelf_focus_cycler_(std::make_unique<ShelfFocusCycler>(this)),
      tooltip_(std::make_unique<ShelfTooltipManager>(this)) {}

Shelf::~Shelf() = default;

// static
Shelf* Shelf::ForWindow(aura::Window* window) {
  return RootWindowController::ForWindow(window)->shelf();
}

// static
void Shelf::LaunchShelfItem(int item_index) {
  const int item_count = ShelfModel::Get()->item_count();

  // A negative argument will launch the last app. A positive argument will
  // launch the app at the corresponding index, unless it's higher than the
  // total number of apps, in which case we do nothing.
  if (item_index >= item_count)
    return;

  const int found_index = item_index >= 0 ? item_index : item_count - 1;

  // Set this one as active (or advance to the next item of its kind).
  ActivateShelfItem(found_index);
}

// static
void Shelf::ActivateShelfItem(int item_index) {
  ActivateShelfItemOnDisplay(item_index, display::kInvalidDisplayId);
}

// static
void Shelf::ActivateShelfItemOnDisplay(int item_index, int64_t display_id) {
  const ShelfModel* shelf_model = ShelfModel::Get();
  const ShelfItem& item = shelf_model->items()[item_index];
  ShelfItemDelegate* item_delegate = shelf_model->GetShelfItemDelegate(item.id);
  std::unique_ptr<ui::Event> event = std::make_unique<ui::KeyEvent>(
      ui::EventType::kKeyReleased, ui::VKEY_UNKNOWN, ui::EF_NONE);
  item_delegate->ItemSelected(std::move(event), display_id, LAUNCH_FROM_SHELF,
                              base::DoNothing(), base::NullCallback());
}

// static
void Shelf::UpdateShelfVisibility() {
  for (aura::Window* root : Shell::Get()->GetAllRootWindows()) {
    Shelf::ForWindow(root)->UpdateVisibilityState();
  }
}

void Shelf::CreateNavigationWidget(aura::Window* container) {
  DCHECK(container);
  DCHECK(!navigation_widget_);
  navigation_widget_ = std::make_unique<ShelfNavigationWidget>(
      this, hotseat_widget()->GetShelfView());
  navigation_widget_->Initialize(container);
  navigation_widget_metrics_reporter_ =
      std::make_unique<NavigationWidgetAnimationMetricsReporter>();
}

void Shelf::CreateDeskButtonWidget(aura::Window* container) {
  CHECK(container);
  CHECK(!desk_button_widget_);
  CHECK(ash::features::IsDeskButtonEnabled());

  desk_button_widget_ = std::make_unique<DeskButtonWidget>(this);
  desk_button_widget_->Initialize(container);
}

void Shelf::CreateHotseatWidget(aura::Window* container) {
  DCHECK(container);
  DCHECK(!hotseat_widget_);
  hotseat_widget_ = std::make_unique<HotseatWidget>();
  translucent_background_metrics_reporter_ =
      std::make_unique<HotseatWidgetAnimationMetricsReporter>(
          HotseatWidgetAnimationMetricsReporter::HotseatElementType::
              kTranslucentBackground);
  hotseat_widget_->Initialize(container, this);
  shelf_widget_->RegisterHotseatWidget(hotseat_widget());
  hotseat_transition_metrics_reporter_ =
      std::make_unique<HotseatWidgetAnimationMetricsReporter>(
          HotseatWidgetAnimationMetricsReporter::HotseatElementType::kWidget);
}

void Shelf::CreateStatusAreaWidget(aura::Window* shelf_container) {
  DCHECK(shelf_container);
  DCHECK(!status_area_widget_);
  status_area_widget_ =
      std::make_unique<StatusAreaWidget>(shelf_container, this);
  status_area_widget_->Initialize();
}

void Shelf::CreateShelfWidget(aura::Window* root) {
  DCHECK(!shelf_widget_);
  aura::Window* shelf_container =
      root->GetChildById(kShellWindowId_ShelfContainer);
  shelf_widget_ = std::make_unique<ShelfWidget>(this);

  DCHECK(!shelf_layout_manager_);
  shelf_layout_manager_ = shelf_widget_->shelf_layout_manager();
  shelf_layout_manager_->AddObserver(this);

  // Create the various shelf components.
  CreateHotseatWidget(shelf_container);
  CreateNavigationWidget(shelf_container);
  if (ash::features::IsDeskButtonEnabled()) {
    CreateDeskButtonWidget(shelf_container);
  }
  login_shelf_widget_ =
      std::make_unique<LoginShelfWidget>(/*shelf=*/this, shelf_container);

  // Must occur after |shelf_widget_| is constructed because the system tray
  // constructors call back into Shelf::shelf_widget().
  CreateStatusAreaWidget(shelf_container);
  shelf_widget_->Initialize(shelf_container);
  shelf_widget_->GetNativeWindow()->parent()->StackChildAtBottom(
      shelf_widget_->GetNativeWindow());

  // The Hotseat should be above everything in the shelf.
  hotseat_widget()->StackAtTop();

  // Some accessibility properties depends on hotseat widget and desk button
  // widget that are instantiated later on, thus why we call it towards the end
  // of this function.
  hotseat_widget()->InitializeAccessibilityProperties();
  desk_button_widget()->InitializeAccessibleProperties();
  status_area_widget_->InitializeTrayButtonsAccessibleNavFocus();
}

void Shelf::ShutdownShelfWidget() {
  for (auto& observer : observers_)
    observer.OnShelfShuttingDown();

  // Remove observers prior to destroying child widgets, this prevents
  // activation changes from triggering during shutdown, see
  // https://crbug.com/1307898.
  shelf_widget_->Shutdown();

  // The contents view of the hotseat widget may rely on the status area widget.
  // So do explicit destruction here.
  hotseat_widget_.reset();
  status_area_widget_.reset();
  navigation_widget_.reset();
  login_shelf_widget_.reset();
}

void Shelf::DestroyShelfWidget() {
  DCHECK(shelf_widget_);
  shelf_widget_.reset();
}

bool Shelf::IsVisible() const {
  return shelf_layout_manager_->IsVisible();
}

const aura::Window* Shelf::GetWindow() const {
  return shelf_widget_ ? shelf_widget_->GetNativeWindow() : nullptr;
}

aura::Window* Shelf::GetWindow() {
  return const_cast<aura::Window*>(const_cast<const Shelf*>(this)->GetWindow());
}

void Shelf::SetAlignment(ShelfAlignment alignment) {
  if (!shelf_widget_)
    return;

  if (alignment_ == alignment)
    return;

  if (shelf_locking_manager_.is_locked() &&
      alignment != ShelfAlignment::kBottomLocked) {
    shelf_locking_manager_.set_in_session_alignment(alignment);
    return;
  }

  bool needs_relayout =
      !IsBottomAlignment(alignment_) || !IsBottomAlignment(alignment);

  ShelfAlignment old_alignment = alignment_;
  alignment_ = alignment;
  tooltip_->Close();
  if (needs_relayout) {
    shelf_layout_manager_->HandleShelfAlignmentChange();
    Shell::Get()->NotifyShelfAlignmentChanged(GetWindow()->GetRootWindow(),
                                              old_alignment);
  }
}

bool IsHorizontalAlignment(ShelfAlignment alignment) {
  switch (alignment) {
    case ShelfAlignment::kBottom:
    case ShelfAlignment::kBottomLocked:
      return true;
    case ShelfAlignment::kLeft:
    case ShelfAlignment::kRight:
      return false;
  }
  NOTREACHED();
}

bool Shelf::IsHorizontalAlignment() const {
  return ash::IsHorizontalAlignment(alignment_);
}

void Shelf::SetAutoHideBehavior(ShelfAutoHideBehavior auto_hide_behavior) {
  DCHECK(shelf_layout_manager_);

  if (auto_hide_behavior_ == auto_hide_behavior)
    return;

  auto_hide_behavior_ = auto_hide_behavior;

  for (auto& observer : observers_)
    observer.OnShelfAutoHideBehaviorChanged();
}

ShelfAutoHideState Shelf::GetAutoHideState() const {
  return shelf_layout_manager_->auto_hide_state();
}

void Shelf::UpdateAutoHideState() {
  shelf_layout_manager_->UpdateAutoHideState();
}

ShelfBackgroundType Shelf::GetBackgroundType() const {
  return shelf_layout_manager_ ? shelf_layout_manager_->shelf_background_type()
                               : ShelfBackgroundType::kDefaultBg;
}

void Shelf::UpdateVisibilityState() {
  if (shelf_layout_manager_)
    shelf_layout_manager_->UpdateVisibilityState(/*force_layout=*/false);
}

void Shelf::MaybeUpdateShelfBackground() {
  if (!shelf_layout_manager_)
    return;

  shelf_layout_manager_->MaybeUpdateShelfBackground(
      AnimationChangeType::ANIMATE);
}

ShelfVisibilityState Shelf::GetVisibilityState() const {
  return shelf_layout_manager_ ? shelf_layout_manager_->visibility_state()
                               : SHELF_HIDDEN;
}

gfx::Rect Shelf::GetShelfBoundsInScreen() const {
  return shelf_widget()->GetTargetBounds();
}

gfx::Rect Shelf::GetIdealBounds() const {
  return shelf_layout_manager_->GetIdealBounds();
}

gfx::Rect Shelf::GetIdealBoundsForWorkAreaCalculation() {
  return shelf_layout_manager_->GetIdealBoundsForWorkAreaCalculation();
}

gfx::Rect Shelf::GetScreenBoundsOfItemIconForWindow(aura::Window* window) {
  if (!shelf_widget_)
    return gfx::Rect();
  return shelf_widget_->GetScreenBoundsOfItemIconForWindow(window);
}

bool Shelf::ProcessGestureEvent(const ui::GestureEvent& event) {
  // Can be called at login screen.
  if (!shelf_layout_manager_)
    return false;
  return shelf_layout_manager_->ProcessGestureEvent(event);
}

void Shelf::ProcessMouseEvent(const ui::MouseEvent& event) {
  if (shelf_layout_manager_)
    shelf_layout_manager_->ProcessMouseEventFromShelf(event);
}

void Shelf::ProcessScrollEvent(ui::ScrollEvent* event) {
  if (event->finger_count() != 2 || event->type() != ui::EventType::kScroll) {
    return;
  }

  if (!shelf_layout_manager_->is_active_session_state())
    return;

  // Introduce the swipe up gesture behind a flag over certain conditions.
  if (!shelf_layout_manager_->IsBubbleLauncherShowOnGestureScrollAvailable())
    return;

  auto* app_list_controller = Shell::Get()->app_list_controller();
  DCHECK(app_list_controller);

  shelf_layout_manager_->ProcessScrollEventFromShelf(event);
  event->SetHandled();
}

void Shelf::ProcessMouseWheelEvent(ui::MouseWheelEvent* event) {
  if (!shelf_layout_manager_->is_active_session_state() ||
      !IsHorizontalAlignment())
    return;

  // Introduce the swipe up gesture behind a flag over certain conditions.
  if (!shelf_layout_manager_->IsBubbleLauncherShowOnGestureScrollAvailable())
    return;

  auto* app_list_controller = Shell::Get()->app_list_controller();
  DCHECK(app_list_controller);

  shelf_layout_manager_->ProcessMouseWheelEventFromShelf(event);
  event->SetHandled();
}

void Shelf::AddObserver(ShelfObserver* observer) {
  observers_.AddObserver(observer);
}

void Shelf::RemoveObserver(ShelfObserver* observer) {
  observers_.RemoveObserver(observer);
}

void Shelf::NotifyShelfIconPositionsChanged() {
  for (auto& observer : observers_)
    observer.OnShelfIconPositionsChanged();
}

StatusAreaWidget* Shelf::GetStatusAreaWidget() const {
  return shelf_widget_ ? shelf_widget_->status_area_widget() : nullptr;
}

gfx::Rect Shelf::GetSystemTrayAnchorRect() const {
  gfx::Rect work_area = GetWorkAreaInsets()->user_work_area_bounds();
  switch (alignment_) {
    case ShelfAlignment::kBottom:
    case ShelfAlignment::kBottomLocked:
      return gfx::Rect(base::i18n::IsRTL()
                           ? work_area.x()
                           : work_area.right() - kShelfDisplayOffset,
                       work_area.bottom() - kShelfDisplayOffset, 0, 0);
    case ShelfAlignment::kLeft:
      return gfx::Rect(work_area.x(), work_area.bottom() - kShelfDisplayOffset,
                       0, 0);
    case ShelfAlignment::kRight:
      return gfx::Rect(work_area.right() - kShelfDisplayOffset,
                       work_area.bottom() - kShelfDisplayOffset, 0, 0);
  }
  NOTREACHED();
}

bool Shelf::ShouldHideOnSecondaryDisplay(session_manager::SessionState state) {
  if (Shell::GetPrimaryRootWindowController()->shelf() == this)
    return false;

  return state != session_manager::SessionState::ACTIVE;
}

void Shelf::SetVirtualKeyboardBoundsForTesting(const gfx::Rect& bounds) {
  KeyboardStateDescriptor state;
  state.is_visible = !bounds.IsEmpty();
  state.visual_bounds = bounds;
  state.occluded_bounds_in_screen = bounds;
  state.displaced_bounds_in_screen = gfx::Rect();
  WorkAreaInsets* work_area_insets = GetWorkAreaInsets();
  work_area_insets->OnKeyboardVisibilityChanged(state.is_visible);
  work_area_insets->OnKeyboardVisibleBoundsChanged(state.visual_bounds);
  work_area_insets->OnKeyboardOccludedBoundsChanged(
      state.occluded_bounds_in_screen);
  work_area_insets->OnKeyboardDisplacingBoundsChanged(
      state.displaced_bounds_in_screen);
  work_area_insets->OnKeyboardAppearanceChanged(state);
}

ShelfLockingManager* Shelf::GetShelfLockingManagerForTesting() {
  return &shelf_locking_manager_;
}

ShelfView* Shelf::GetShelfViewForTesting() {
  return shelf_widget_->shelf_view_for_testing();
}

metrics_util::ReportCallback Shelf::GetHotseatTransitionReportCallback(
    HotseatState target_state) {
  return hotseat_transition_metrics_reporter_->GetReportCallback(target_state);
}

metrics_util::ReportCallback Shelf::GetTranslucentBackgroundReportCallback(
    HotseatState target_state) {
  return translucent_background_metrics_reporter_->GetReportCallback(
      target_state);
}

metrics_util::ReportCallback Shelf::GetNavigationWidgetAnimationReportCallback(
    HotseatState target_hotseat_state) {
  return navigation_widget_metrics_reporter_->GetReportCallback(
      target_hotseat_state);
}

void Shelf::WillDeleteShelfLayoutManager() {
  // Clear event handlers that might forward events to the destroyed instance.
  auto_hide_event_handler_.reset();
  auto_dim_event_handler_.reset();
  navigation_widget_metrics_reporter_.reset();

  DCHECK(shelf_layout_manager_);
  shelf_layout_manager_->RemoveObserver(this);
  shelf_layout_manager_ = nullptr;
}

void Shelf::OnShelfVisibilityStateChanged(ShelfVisibilityState new_state) {
  if (!auto_dim_event_handler_ && switches::IsUsingShelfAutoDim()) {
    auto_dim_event_handler_ = std::make_unique<AutoDimEventHandler>(this);
  }

  if (new_state != SHELF_AUTO_HIDE) {
    auto_hide_event_handler_.reset();
  } else if (!auto_hide_event_handler_) {
    auto_hide_event_handler_ = std::make_unique<AutoHideEventHandler>(this);
  }

  for (auto& observer : observers_) {
    observer.OnShelfVisibilityStateChanged(new_state);
  }
}

void Shelf::OnAutoHideStateChanged(ShelfAutoHideState new_state) {
  for (auto& observer : observers_)
    observer.OnAutoHideStateChanged(new_state);
}

void Shelf::OnBackgroundUpdated(ShelfBackgroundType background_type,
                                AnimationChangeType change_type) {
  // Shelf should undim when transitioning to show app list.
  if (auto_dim_event_handler_ && IsAppListBackground(background_type))
    UndimShelf();

  for (auto& observer : observers_)
    observer.OnBackgroundTypeChanged(background_type, change_type);
}

void Shelf::OnHotseatStateChanged(HotseatState old_state,
                                  HotseatState new_state) {
  for (auto& observer : observers_)
    observer.OnHotseatStateChanged(old_state, new_state);
}

void Shelf::OnWorkAreaInsetsChanged() {
  for (auto& observer : observers_)
    observer.OnShelfWorkAreaInsetsChanged();
}

void Shelf::DimShelf() {
  auto_dim_event_handler_->DimShelf();
}

void Shelf::UndimShelf() {
  auto_dim_event_handler_->UndimShelf();
}

bool Shelf::HasDimShelfTimer() {
  return auto_dim_event_handler_->HasDimShelfTimer();
}

WorkAreaInsets* Shelf::GetWorkAreaInsets() const {
  const aura::Window* window = GetWindow();
  DCHECK(window);
  return WorkAreaInsets::ForWindow(window->GetRootWindow());
}

base::WeakPtr<Shelf> Shelf::GetWeakPtr() {
  return weak_ptr_factory_.GetWeakPtr();
}

}  // namespace ash