mash: Partially migrate ShelfLayoutManager to ash common types.

ash/shelf/shelf_layout_manager.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "ash/shelf/shelf_layout_manager.h"
 
 #include <algorithm>
 #include <cmath>
-#include <cstring>
-#include <string>
 #include <vector>
 
-#include "ash/aura/wm_window_aura.h"
-#include "ash/common/accelerators/accelerator_commands.h"
-#include "ash/common/ash_switches.h"
 #include "ash/common/material_design/material_design_controller.h"
 #include "ash/common/session/session_state_delegate.h"
 #include "ash/common/shelf/shelf_constants.h"
 #include "ash/common/shelf/shelf_delegate.h"
 #include "ash/common/shelf/wm_shelf_util.h"
 #include "ash/common/shell_window_ids.h"
 #include "ash/common/system/status_area_widget.h"
+#include "ash/common/wm/fullscreen_window_finder.h"
 #include "ash/common/wm/mru_window_tracker.h"
 #include "ash/common/wm/window_state.h"
+#include "ash/common/wm_lookup.h"
 #include "ash/common/wm_root_window_controller.h"
 #include "ash/common/wm_root_window_controller_observer.h"
 #include "ash/common/wm_shell.h"
-#include "ash/root_window_controller.h"
+#include "ash/common/wm_window.h"
 #include "ash/screen_util.h"
 #include "ash/shelf/shelf.h"
 #include "ash/shelf/shelf_bezel_event_filter.h"
 #include "ash/shelf/shelf_layout_manager_observer.h"
-#include "ash/shelf/shelf_util.h"
-#include "ash/shelf/shelf_widget.h"
 #include "ash/shell.h"
 #include "ash/wm/gestures/shelf_gesture_handler.h"
 #include "ash/wm/window_animations.h"
-#include "ash/wm/window_state_aura.h"
-#include "ash/wm/window_util.h"
 #include "ash/wm/workspace_controller.h"
 #include "base/auto_reset.h"
-#include "base/command_line.h"
 #include "base/i18n/rtl.h"
-#include "base/strings/string_number_conversions.h"
-#include "base/strings/string_util.h"
-#include "ui/aura/client/cursor_client.h"
-#include "ui/aura/window_event_dispatcher.h"
-#include "ui/base/ui_base_switches.h"
 #include "ui/compositor/layer.h"
 #include "ui/compositor/layer_animation_observer.h"
 #include "ui/compositor/layer_animator.h"
 #include "ui/compositor/scoped_layer_animation_settings.h"
+#include "ui/display/display.h"
 #include "ui/display/screen.h"
 #include "ui/events/event.h"
 #include "ui/events/event_handler.h"
 #include "ui/keyboard/keyboard_util.h"
 #include "ui/views/border.h"
 #include "ui/views/widget/widget.h"
-#include "ui/wm/public/activation_client.h"
 
 namespace ash {
 namespace {
 
 // Delay before showing the shelf. This is after the mouse stops moving.
 const int kAutoHideDelayMS = 200;
 
 // To avoid hiding the shelf when the mouse transitions from a message bubble
 // into the shelf, the hit test area is enlarged by this amount of pixels to
 // keep the shelf from hiding.
@@ skipping 60 matching lines @@
         event->type() != ui::ET_MOUSE_CAPTURE_CHANGED)) &&
       !shelf_->IsShelfWindow(static_cast<aura::Window*>(event->target()));
   shelf_->UpdateAutoHideForMouseEvent(event);
 }
 
 void ShelfLayoutManager::AutoHideEventFilter::OnGestureEvent(
     ui::GestureEvent* event) {
   shelf_->UpdateAutoHideForGestureEvent(event);
 }
 
-// ShelfLayoutManager:UpdateShelfObserver --------------------------------------
+// ShelfLayoutManager::UpdateShelfObserver -------------------------------------
 
 // UpdateShelfObserver is used to delay updating the background until the
 // animation completes.
 class ShelfLayoutManager::UpdateShelfObserver
     : public ui::ImplicitAnimationObserver {
  public:
   explicit UpdateShelfObserver(ShelfLayoutManager* shelf) : shelf_(shelf) {
     shelf_->update_shelf_observer_ = this;
   }
 
@@ skipping 23 matching lines @@
 // via WmRootWindowControllerObserver instead of via ShellObserver. There are
 // implicit assumptions that these layout managers run in order. In order to
 // preserve the ordering, OnShelfAlignmentChanged() is implemented here in terms
 // of a WmRootWindowControllerObserver instead of a ShellObserver. This gives us
 // a sane ordering (or at least ordering as we've always had it in ash).
 class ShelfLayoutManager::RootWindowControllerObserverImpl
     : public WmRootWindowControllerObserver {
  public:
   explicit RootWindowControllerObserverImpl(
       ShelfLayoutManager* shelf_layout_manager)
-      : shelf_layout_manager_(shelf_layout_manager) {}
-  ~RootWindowControllerObserverImpl() override {}
+      : shelf_layout_manager_(shelf_layout_manager) {
+    WmLookup::Get()
+        ->GetWindowForWidget(shelf_layout_manager_->shelf_widget())
+        ->GetRootWindowController()
+        ->AddObserver(this);
+  }
+  ~RootWindowControllerObserverImpl() override {
+    views::Widget* widget = shelf_layout_manager_->shelf_widget();
+    if (widget && WmLookup::Get()->GetWindowForWidget(widget)) {

[James Cook, 2016/07/27 03:15:11]

Just curious, is |widget| null in tests, or does that happen in normal shutdown?

[msw, 2016/07/27 22:31:17]

Neither. |window| may be null; I removed the extra widget check.

+      WmLookup::Get()
+          ->GetWindowForWidget(widget)
+          ->GetRootWindowController()
+          ->RemoveObserver(this);
+    }
+  }
 
   // WmRootWindowControllerObserver:
   void OnShelfAlignmentChanged() override {
     shelf_layout_manager_->LayoutShelf();
   }
 
  private:
   ShelfLayoutManager* shelf_layout_manager_;
 
   DISALLOW_COPY_AND_ASSIGN(RootWindowControllerObserverImpl);
 };
 
 // ShelfLayoutManager ----------------------------------------------------------
 
 ShelfLayoutManager::ShelfLayoutManager(ShelfWidget* shelf_widget)
     : SnapToPixelLayoutManager(shelf_widget->GetNativeView()->parent()),
       root_window_(shelf_widget->GetNativeView()->GetRootWindow()),
       updating_bounds_(false),
       shelf_widget_(shelf_widget),
       workspace_controller_(NULL),
       window_overlaps_shelf_(false),
       mouse_over_shelf_when_auto_hide_timer_started_(false),
       bezel_event_filter_(new ShelfBezelEventFilter(this)),
       gesture_drag_status_(GESTURE_DRAG_NONE),
       gesture_drag_amount_(0.f),
       gesture_drag_auto_hide_state_(SHELF_AUTO_HIDE_SHOWN),
       update_shelf_observer_(NULL),
       chromevox_panel_height_(0),
-      duration_override_in_ms_(0) {
+      duration_override_in_ms_(0),
+      root_window_controller_observer_(
+          new RootWindowControllerObserverImpl(this)) {
   WmShell::Get()->AddShellObserver(this);
-
-  if (!Shell::GetInstance()->in_mus()) {
-    root_window_controller_observer_.reset(
-        new RootWindowControllerObserverImpl(this));
-    WmWindowAura::Get(root_window_)
-        ->GetRootWindowController()
-        ->AddObserver(root_window_controller_observer_.get());
-  }
   WmShell::Get()->AddLockStateObserver(this);
-  aura::client::GetActivationClient(root_window_)->AddObserver(this);
+  WmShell::Get()->AddActivationObserver(this);
   WmShell::Get()->GetSessionStateDelegate()->AddSessionStateObserver(this);
 }
 
 ShelfLayoutManager::~ShelfLayoutManager() {
   if (update_shelf_observer_)
     update_shelf_observer_->Detach();
 
   FOR_EACH_OBSERVER(ShelfLayoutManagerObserver, observers_,
                     WillDeleteShelfLayoutManager());
   WmShell::Get()->RemoveShellObserver(this);
   WmShell::Get()->RemoveLockStateObserver(this);
-  WmShell::Get()->GetSessionStateDelegate()->RemoveSessionStateObserver(
-      this);
-  if (root_window_controller_observer_) {
-    WmWindowAura::Get(root_window_)
-        ->GetRootWindowController()
-        ->RemoveObserver(root_window_controller_observer_.get());
-  }
+  WmShell::Get()->GetSessionStateDelegate()->RemoveSessionStateObserver(this);
 }
 
 void ShelfLayoutManager::PrepareForShutdown() {
   in_shutdown_ = true;
   // Clear all event filters, otherwise sometimes those filters may catch
   // synthesized mouse event and cause crashes during the shutdown.
   set_workspace_controller(NULL);
   auto_hide_event_filter_.reset();
   bezel_event_filter_.reset();
-  // Stop observing window change, otherwise we can attempt to update a
-  // partially destructed shelf.
-  aura::client::GetActivationClient(root_window_)->RemoveObserver(this);
+  // Stop observing changes to avoid updating a partially destructed shelf.
+  WmShell::Get()->RemoveActivationObserver(this);
 }
 
 bool ShelfLayoutManager::IsVisible() const {
   // status_area_widget() may be NULL during the shutdown.
   return shelf_widget_->status_area_widget() &&
          shelf_widget_->status_area_widget()->IsVisible() &&
          (state_.visibility_state == SHELF_VISIBLE ||
           (state_.visibility_state == SHELF_AUTO_HIDE &&
            state_.auto_hide_state == SHELF_AUTO_HIDE_SHOWN));
 }
@@ skipping 47 matching lines @@
     SetState(SHELF_VISIBLE);
   } else if (WmShell::Get()->IsPinned()) {
     SetState(SHELF_HIDDEN);
   } else {
     // TODO(zelidrag): Verify shelf drag animation still shows on the device
     // when we are in SHELF_AUTO_HIDE_ALWAYS_HIDDEN.
     wm::WorkspaceWindowState window_state(
         workspace_controller_->GetWindowState());
     switch (window_state) {
       case wm::WORKSPACE_WINDOW_STATE_FULL_SCREEN: {
-        const aura::Window* fullscreen_window =
-            GetRootWindowController(root_window_)->GetWindowForFullscreenMode();
+        const WmWindow* fullscreen_window = wm::GetWindowForFullscreenMode(
+            WmLookup::Get()->GetWindowForWidget(shelf_widget_));

[James Cook, 2016/07/27 03:15:11]

totally optional: Are you thinking that long-term |root_window_| will go away
and everything will compute it from |shelf_widget_|?  If you think we'll need it
longer-term you could cache a |wm_root_window_| in the constructor. Or introduce
a GetRootWindowForShelf() utility method.

[msw, 2016/07/27 22:31:17]

Yeah, we can probably nuke |root_window_| soon; computing the WmWindow from
|shelf_widget_| makes sense for now, but we don't need the root WmWindow for
most stuff; caching a WmWindow* |shelf_window_| (or adding some helper) might
make sense, but I'll punt on that for now.

         if (fullscreen_window &&
-            wm::GetWindowState(fullscreen_window)
-                ->hide_shelf_when_fullscreen()) {
+            fullscreen_window->GetWindowState()->hide_shelf_when_fullscreen()) {
           SetState(SHELF_HIDDEN);
         } else {
           // The shelf is sometimes not hidden when in immersive fullscreen.
           // Force the shelf to be auto hidden in this case.
           SetState(SHELF_AUTO_HIDE);
         }
         break;
       }
 
       case wm::WORKSPACE_WINDOW_STATE_MAXIMIZED:
@@ skipping 213 matching lines @@
 void ShelfLayoutManager::OnShelfAutoHideBehaviorChanged(WmWindow* root_window) {
   UpdateVisibilityState();
 }
 
 void ShelfLayoutManager::OnPinnedStateChanged(WmWindow* pinned_window) {
   // Shelf needs to be hidden on entering to pinned mode, or restored
   // on exiting from pinned mode.
   UpdateVisibilityState();
 }
 
-void ShelfLayoutManager::OnWindowActivated(
-    aura::client::ActivationChangeObserver::ActivationReason reason,
-    aura::Window* gained_active,
-    aura::Window* lost_active) {
+void ShelfLayoutManager::OnWindowActivated(WmWindow* gained_active,
+                                           WmWindow* lost_active) {
   UpdateAutoHideStateNow();
 }
 
 void ShelfLayoutManager::OnKeyboardBoundsChanging(const gfx::Rect& new_bounds) {
   bool keyboard_is_about_to_hide = false;
   if (new_bounds.IsEmpty() && !keyboard_bounds_.IsEmpty())
     keyboard_is_about_to_hide = true;
 
   keyboard_bounds_ = new_bounds;
   OnWindowResized();
@@ skipping 452 matching lines @@
 
 ShelfAutoHideState ShelfLayoutManager::CalculateAutoHideState(
     ShelfVisibilityState visibility_state) const {
   if (visibility_state != SHELF_AUTO_HIDE || !shelf_widget_ ||
       !shelf_widget_->shelf())
     return SHELF_AUTO_HIDE_HIDDEN;
 
   // Unhide the shelf only on the active screen when the AppList is shown
   // (crbug.com/312445).
   if (WmShell::Get()->GetAppListTargetVisibility()) {
-    aura::Window* active_window = wm::GetActiveWindow();
-    aura::Window* shelf_window = shelf_widget_->GetNativeWindow();
+    WmWindow* active_window = WmShell::Get()->GetActiveWindow();
+    WmWindow* shelf_window = WmLookup::Get()->GetWindowForWidget(shelf_widget_);
     if (active_window && shelf_window &&
-        active_window->GetRootWindow() == shelf_window->GetRootWindow()) {
+        active_window->GetRootWindow()->GetDisplayNearestWindow().id() ==
+            shelf_window->GetRootWindow()->GetDisplayNearestWindow().id()) {
       return SHELF_AUTO_HIDE_SHOWN;
     }
   }
 
   if (shelf_widget_->status_area_widget() &&
       shelf_widget_->status_area_widget()->ShouldShowShelf())
     return SHELF_AUTO_HIDE_SHOWN;
 
   if (shelf_widget_->shelf() && shelf_widget_->shelf()->IsShowingMenu())
     return SHELF_AUTO_HIDE_SHOWN;
 
   if (shelf_widget_->shelf() &&
       shelf_widget_->shelf()->IsShowingOverflowBubble())
     return SHELF_AUTO_HIDE_SHOWN;
 
   if (shelf_widget_->IsActive() ||
       (shelf_widget_->status_area_widget() &&
        shelf_widget_->status_area_widget()->IsActive()))
     return SHELF_AUTO_HIDE_SHOWN;
 
   // TODO(jamescook): Track visible windows on mash via ShelfDelegate.
   if (!Shell::GetInstance()->in_mus()) {
     const std::vector<WmWindow*> windows =
         WmShell::Get()->mru_window_tracker()->BuildWindowListIgnoreModal();
 
     // Process the window list and check if there are any visible windows.
     bool visible_window = false;
+    int64_t display_id = WmLookup::Get()

[James Cook, 2016/07/27 03:15:11]

Would it work to use this for the applist check?

[msw, 2016/07/27 22:31:17]

Done.

+                             ->GetWindowForWidget(shelf_widget_)
+                             ->GetDisplayNearestWindow()
+                             .id();
     for (size_t i = 0; i < windows.size(); ++i) {
       if (windows[i] && windows[i]->IsVisible() &&
           !windows[i]->GetWindowState()->IsMinimized() &&
-          root_window_ ==
-              WmWindowAura::GetAuraWindow(windows[i]->GetRootWindow())) {
+          windows[i]->GetDisplayNearestWindow().id() == display_id) {
         visible_window = true;
         break;
       }
     }
     // If there are no visible windows do not hide the shelf.
     if (!visible_window)
       return SHELF_AUTO_HIDE_SHOWN;
   }
 
   if (gesture_drag_status_ == GESTURE_DRAG_COMPLETE_IN_PROGRESS)
     return gesture_drag_auto_hide_state_;
 
   // Don't show if the user is dragging the mouse.
   if (auto_hide_event_filter_.get() && auto_hide_event_filter_->in_mouse_drag())
     return SHELF_AUTO_HIDE_HIDDEN;
 
   // Ignore the mouse position if mouse events are disabled.
-  aura::client::CursorClient* cursor_client = aura::client::GetCursorClient(
-      shelf_widget_->GetNativeWindow()->GetRootWindow());
-  if (!cursor_client->IsMouseEventsEnabled())
+  if (!shelf_widget_->IsMouseEventsEnabled())
     return SHELF_AUTO_HIDE_HIDDEN;
 
   gfx::Rect shelf_region = shelf_widget_->GetWindowBoundsInScreen();
   if (shelf_widget_->status_area_widget() &&
       shelf_widget_->status_area_widget()->IsMessageBubbleShown() &&
       IsVisible()) {
     // Increase the the hit test area to prevent the shelf from disappearing
     // when the mouse is over the bubble gap.
     ShelfAlignment alignment = GetAlignment();
     shelf_region.Inset(
@@ skipping 103 matching lines @@
   if (ash::MaterialDesignController::IsShelfMaterial()) {
     return (state.visibility_state == SHELF_AUTO_HIDE &&
             state.auto_hide_state == SHELF_AUTO_HIDE_SHOWN)
                ? 1.0f
                : 0.0f;
   }
   return (state.visibility_state == SHELF_AUTO_HIDE) ? 1.0f : 0.0f;
 }
 
 }  // namespace ash