mash: Remove some WmWindow usage in ash/shelf.

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 <vector>
 
@@ skipping 59 matching lines @@
 // from the right edge of the primary display which can trigger showing the
 // auto hidden shelf. The region is used to make it easier to trigger showing
 // the auto hidden shelf when the shelf is on the boundary between displays.
 const int kMaxAutoHideShowShelfRegionSize = 10;
 
 ui::Layer* GetLayer(views::Widget* widget) {
   return widget->GetNativeView()->layer();
 }
 
 // Returns true if the window is in the app list window container.
-bool IsAppListWindow(WmWindow* window) {
-  return window->GetParent() && window->GetParent()->aura_window()->id() ==
-                                    kShellWindowId_AppListContainer;
+bool IsAppListWindow(const aura::Window* window) {
+  const aura::Window* parent = window->parent();
+  return parent && parent->id() == kShellWindowId_AppListContainer;
 }
 
 }  // namespace
 
 // ShelfLayoutManager::UpdateShelfObserver -------------------------------------
 
 // UpdateShelfObserver is used to delay updating the background until the
 // animation completes.
 class ShelfLayoutManager::UpdateShelfObserver
     : public ui::ImplicitAnimationObserver {
@@ skipping 135 matching lines @@
     case SHELF_AUTO_HIDE_BEHAVIOR_NEVER:
       return SHELF_VISIBLE;
     case SHELF_AUTO_HIDE_ALWAYS_HIDDEN:
       return SHELF_HIDDEN;
   }
   return SHELF_VISIBLE;
 }
 
 void ShelfLayoutManager::UpdateVisibilityState() {
   // Bail out early before the shelf is initialized or after it is destroyed.
-  WmWindow* shelf_window = WmWindow::Get(shelf_widget_->GetNativeWindow());
+  aura::Window* shelf_window = shelf_widget_->GetNativeWindow();

[James Cook, 2017/05/16 21:50:16]

Your patch and mine are going to conflict here. Yours is simpler - you go first
and I'll rebase.

   if (in_shutdown_ || !wm_shelf_->IsShelfInitialized() || !shelf_window)
     return;
   if (state_.IsScreenLocked() || state_.IsAddingSecondaryUser()) {
     SetState(SHELF_VISIBLE);
   } else if (Shell::Get()->screen_pinning_controller()->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(
-        shelf_window->GetRootWindowController()->GetWorkspaceWindowState());
+        RootWindowController::ForWindow(shelf_window)
+            ->GetWorkspaceWindowState());
 
     switch (window_state) {
       case wm::WORKSPACE_WINDOW_STATE_FULL_SCREEN: {
         if (IsShelfAutoHideForFullscreenMaximized()) {
           SetState(SHELF_AUTO_HIDE);
         } else if (IsShelfHiddenForFullscreen()) {
           SetState(SHELF_HIDDEN);
         } else {
           // The shelf is sometimes not hidden when in immersive fullscreen.
           // Force the shelf to be auto hidden in this case.
@@ skipping 35 matching lines @@
       auto_hide_timer_.Start(
           FROM_HERE, base::TimeDelta::FromMilliseconds(kAutoHideDelayMS), this,
           &ShelfLayoutManager::UpdateAutoHideStateNow);
     }
   } else {
     StopAutoHideTimer();
   }
 }
 
 void ShelfLayoutManager::UpdateAutoHideForMouseEvent(ui::MouseEvent* event,
-                                                     WmWindow* target) {
+                                                     aura::Window* target) {
   // This also checks IsShelfWindow() to make sure we don't attempt to hide the
   // shelf if the mouse down occurs on the shelf.
   in_mouse_drag_ = (event->type() == ui::ET_MOUSE_DRAGGED ||
                     (in_mouse_drag_ && event->type() != ui::ET_MOUSE_RELEASED &&
                      event->type() != ui::ET_MOUSE_CAPTURE_CHANGED)) &&
                    !IsShelfWindow(target);
 
   // Don't update during shutdown because synthetic mouse events (e.g. mouse
   // exit) may be generated during status area widget teardown.
   if (visibility_state() != SHELF_AUTO_HIDE || in_shutdown_)
     return;
 
   if (event->type() == ui::ET_MOUSE_MOVED ||
       event->type() == ui::ET_MOUSE_ENTERED ||
       event->type() == ui::ET_MOUSE_EXITED) {
     UpdateAutoHideState();
   }
 }
 
 void ShelfLayoutManager::UpdateAutoHideForGestureEvent(ui::GestureEvent* event,
-                                                       WmWindow* target) {
+                                                       aura::Window* target) {
   if (visibility_state() != SHELF_AUTO_HIDE || in_shutdown_)
     return;
 
   if (IsShelfWindow(target) && ProcessGestureEvent(*event))
     event->StopPropagation();
 }
 
 void ShelfLayoutManager::SetWindowOverlapsShelf(bool value) {
   window_overlaps_shelf_ = value;
   MaybeUpdateShelfBackground(AnimationChangeType::ANIMATE);
@@ skipping 148 matching lines @@
 ShelfLayoutManager::TargetBounds::TargetBounds()
     : opacity(0.0f), status_opacity(0.0f) {}
 
 ShelfLayoutManager::TargetBounds::~TargetBounds() {}
 
 void ShelfLayoutManager::SetState(ShelfVisibilityState visibility_state) {
   State state;
   state.visibility_state = visibility_state;
   state.auto_hide_state = CalculateAutoHideState(visibility_state);
 
-  WmWindow* shelf_window = WmWindow::Get(shelf_widget_->GetNativeWindow());
-  RootWindowController* controller = shelf_window->GetRootWindowController();
+  RootWindowController* controller =
+      RootWindowController::ForWindow(shelf_widget_->GetNativeWindow());
   state.window_state = controller ? controller->GetWorkspaceWindowState()
                                   : wm::WORKSPACE_WINDOW_STATE_DEFAULT;
   // Preserve the log in screen states.
   state.session_state = state_.session_state;
   state.pre_lock_screen_animation_active =
       state_.pre_lock_screen_animation_active;
 
   // Force an update because gesture drags affect the shelf bounds and we
   // should animate back to the normal bounds at the end of a gesture.
   bool force_update =
@@ skipping 57 matching lines @@
     for (auto& observer : observers_)
       observer.OnAutoHideStateChanged(state_.auto_hide_state);
   }
 }
 
 void ShelfLayoutManager::UpdateBoundsAndOpacity(
     const TargetBounds& target_bounds,
     bool animate,
     bool change_work_area,
     ui::ImplicitAnimationObserver* observer) {
+  StatusAreaWidget* status_widget = shelf_widget_->status_area_widget();
   base::AutoReset<bool> auto_reset_updating_bounds(&updating_bounds_, true);
   {
     ui::ScopedLayerAnimationSettings shelf_animation_setter(
         GetLayer(shelf_widget_)->GetAnimator());
     ui::ScopedLayerAnimationSettings status_animation_setter(
-        GetLayer(shelf_widget_->status_area_widget())->GetAnimator());
+        GetLayer(status_widget)->GetAnimator());
     if (animate) {
       int duration = duration_override_in_ms_ ? duration_override_in_ms_
                                               : kAnimationDurationMS;
       shelf_animation_setter.SetTransitionDuration(
           base::TimeDelta::FromMilliseconds(duration));
       shelf_animation_setter.SetTweenType(gfx::Tween::EASE_OUT);
       shelf_animation_setter.SetPreemptionStrategy(
           ui::LayerAnimator::IMMEDIATELY_ANIMATE_TO_NEW_TARGET);
       status_animation_setter.SetTransitionDuration(
           base::TimeDelta::FromMilliseconds(duration));
       status_animation_setter.SetTweenType(gfx::Tween::EASE_OUT);
       status_animation_setter.SetPreemptionStrategy(
           ui::LayerAnimator::IMMEDIATELY_ANIMATE_TO_NEW_TARGET);
     } else {
       StopAnimating();
       shelf_animation_setter.SetTransitionDuration(base::TimeDelta());
       status_animation_setter.SetTransitionDuration(base::TimeDelta());
     }
     if (observer)
       status_animation_setter.AddObserver(observer);
 
     GetLayer(shelf_widget_)->SetOpacity(target_bounds.opacity);
-    WmWindow* shelf_window = WmWindow::Get(shelf_widget_->GetNativeWindow());
-    shelf_widget_->SetBounds(shelf_window->GetParent()->ConvertRectToScreen(
-        target_bounds.shelf_bounds_in_root));
+    gfx::Rect shelf_bounds = target_bounds.shelf_bounds_in_root;
+    ::wm::ConvertRectToScreen(shelf_widget_->GetNativeWindow()->parent(),
+                              &shelf_bounds);
+    shelf_widget_->SetBounds(shelf_bounds);
 
-    GetLayer(shelf_widget_->status_area_widget())
-        ->SetOpacity(target_bounds.status_opacity);
+    GetLayer(status_widget)->SetOpacity(target_bounds.status_opacity);
 
     // Having a window which is visible but does not have an opacity is an
     // illegal state. We therefore hide the shelf here if required.
     if (!target_bounds.status_opacity)
-      shelf_widget_->status_area_widget()->Hide();
+      status_widget->Hide();
     // Setting visibility during an animation causes the visibility property to
     // animate. Override the animation settings to immediately set the
     // visibility property. Opacity will still animate.
 
     // TODO(harrym): Once status area widget is a child view of shelf
     // this can be simplified.
     gfx::Rect status_bounds = target_bounds.status_bounds_in_shelf;
     status_bounds.Offset(target_bounds.shelf_bounds_in_root.OffsetFromOrigin());
-    WmWindow* status_window =
-        WmWindow::Get(shelf_widget_->status_area_widget()->GetNativeWindow());
-    shelf_widget_->status_area_widget()->SetBounds(
-        status_window->GetParent()->ConvertRectToScreen(status_bounds));
+    ::wm::ConvertRectToScreen(status_widget->GetNativeWindow()->parent(),
+                              &status_bounds);
+    status_widget->SetBounds(status_bounds);
 
     // For crbug.com/622431, when the shelf alignment is BOTTOM_LOCKED, we
     // don't set display work area, as it is not real user-set alignment.
     if (!state_.IsScreenLocked() &&
         wm_shelf_->GetAlignment() != SHELF_ALIGNMENT_BOTTOM_LOCKED &&
         change_work_area) {
       gfx::Insets insets;
       // If user session is blocked (login to new user session or add user to
       // the existing session - multi-profile) then give 100% of work area only
       // if keyboard is not shown.
       if (!state_.IsAddingSecondaryUser() || !keyboard_bounds_.IsEmpty())
         insets = target_bounds.work_area_insets;
+      WmWindow* shelf_window = WmWindow::Get(shelf_widget_->GetNativeWindow());
       ShellPort::Get()->SetDisplayWorkAreaInsets(shelf_window, insets);
     }
   }
 
   // Set an empty border to avoid the shelf view and status area overlapping.
   // TODO(msw): Avoid setting bounds of views within the shelf widget here.
   gfx::Rect shelf_bounds = gfx::Rect(target_bounds.shelf_bounds_in_root.size());
   shelf_widget_->GetContentsView()->SetBorder(views::CreateEmptyBorder(
       shelf_bounds.InsetsFrom(target_bounds.shelf_bounds_in_shelf)));
   shelf_widget_->GetContentsView()->Layout();
 
   // Setting visibility during an animation causes the visibility property to
   // animate. Set the visibility property without an animation.
   if (target_bounds.status_opacity)
-    shelf_widget_->status_area_widget()->Show();
+    status_widget->Show();
 }
 
 void ShelfLayoutManager::StopAnimating() {
   GetLayer(shelf_widget_)->GetAnimator()->StopAnimating();
   GetLayer(shelf_widget_->status_area_widget())->GetAnimator()->StopAnimating();
 }
 
 void ShelfLayoutManager::CalculateTargetBounds(const State& state,
                                                TargetBounds* target_bounds) {
   int shelf_size = kShelfSize;
@@ skipping 205 matching lines @@
 }
 
 bool ShelfLayoutManager::HasVisibleWindow() const {
   WmWindow* root =
       WmWindow::Get(shelf_widget_->GetNativeWindow())->GetRootWindow();
   const std::vector<WmWindow*> windows =
       Shell::Get()->mru_window_tracker()->BuildWindowListIgnoreModal();
   // Process the window list and check if there are any visible windows.
   // Ignore app list windows that may be animating to hide after dismissal.
   for (auto* window : windows) {
-    if (window->IsVisible() && !IsAppListWindow(window) &&
+    if (window->IsVisible() && !IsAppListWindow(window->aura_window()) &&
         root->Contains(window)) {
       return true;
     }
   }
   return false;
 }
 
 ShelfAutoHideState ShelfLayoutManager::CalculateAutoHideState(
     ShelfVisibilityState visibility_state) const {
   if (visibility_state != SHELF_AUTO_HIDE || !wm_shelf_->IsShelfInitialized())
@@ skipping 66 matching lines @@
   if ((state_.auto_hide_state == SHELF_AUTO_HIDE_SHOWN ||
        mouse_over_shelf_when_auto_hide_timer_started_) &&
       GetAutoHideShowShelfRegionInScreen().Contains(
           cursor_position_in_screen)) {
     return SHELF_AUTO_HIDE_SHOWN;
   }
 
   return SHELF_AUTO_HIDE_HIDDEN;
 }
 
-bool ShelfLayoutManager::IsShelfWindow(WmWindow* window) {
+bool ShelfLayoutManager::IsShelfWindow(aura::Window* window) {
   if (!window)
     return false;
-  WmWindow* shelf_window = WmWindow::Get(shelf_widget_->GetNativeWindow());
-  WmWindow* status_window =
-      WmWindow::Get(shelf_widget_->status_area_widget()->GetNativeWindow());
+  const aura::Window* shelf_window = shelf_widget_->GetNativeWindow();
+  const aura::Window* status_window =
+      shelf_widget_->status_area_widget()->GetNativeWindow();
   return (shelf_window && shelf_window->Contains(window)) ||
          (status_window && status_window->Contains(window));
 }
 
 int ShelfLayoutManager::GetWorkAreaInsets(const State& state, int size) const {
   if (state.visibility_state == SHELF_VISIBLE)
     return size;
   return 0;
 }
 
@@ skipping 161 matching lines @@
   gesture_drag_status_ = GESTURE_DRAG_NONE;
 }
 
 void ShelfLayoutManager::CancelGestureDrag() {
   gesture_drag_status_ = GESTURE_DRAG_CANCEL_IN_PROGRESS;
   UpdateVisibilityState();
   gesture_drag_status_ = GESTURE_DRAG_NONE;
 }
 
 }  // namespace ash