Remove Shell::shelf()|status_area_widget()|launcher()

ash/wm/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/wm/shelf_layout_manager.h"
 
 #include <algorithm>
 #include <cmath>
 
 #include "ash/ash_switches.h"
 #include "ash/launcher/launcher.h"
+#include "ash/root_window_controller.h"
 #include "ash/screen_ash.h"
 #include "ash/shell.h"
 #include "ash/shell_delegate.h"
 #include "ash/shell_window_ids.h"
 #include "ash/system/status_area_widget.h"
 #include "ash/wm/workspace_controller.h"
 #include "ash/wm/workspace/workspace_animations.h"
 #include "base/auto_reset.h"
 #include "base/command_line.h"
 #include "base/i18n/rtl.h"
@@ skipping 143 matching lines @@
   }
 
   // Shelf we're in. NULL if deleted before we're deleted.
   ShelfLayoutManager* shelf_;
 
   DISALLOW_COPY_AND_ASSIGN(UpdateShelfObserver);
 };
 
 // ShelfLayoutManager ----------------------------------------------------------
 
-ShelfLayoutManager::ShelfLayoutManager(views::Widget* status)
-    : root_window_(Shell::GetPrimaryRootWindow()),
+ShelfLayoutManager::ShelfLayoutManager(StatusAreaWidget* status_area_widget)
+    : root_window_(status_area_widget->GetNativeView()->GetRootWindow()),
       in_layout_(false),
       auto_hide_behavior_(SHELF_AUTO_HIDE_BEHAVIOR_NEVER),
       alignment_(SHELF_ALIGNMENT_BOTTOM),
       launcher_(NULL),
-      status_(status),
+      status_area_widget_(status_area_widget),
       workspace_controller_(NULL),
       window_overlaps_shelf_(false),
       gesture_drag_status_(GESTURE_DRAG_NONE),
       gesture_drag_amount_(0.f),
       gesture_drag_auto_hide_state_(AUTO_HIDE_SHOWN),
       update_shelf_observer_(NULL) {
   Shell::GetInstance()->AddShellObserver(this);
   aura::client::GetActivationClient(root_window_)->AddObserver(this);
 }
 
 ShelfLayoutManager::~ShelfLayoutManager() {
   if (update_shelf_observer_)
     update_shelf_observer_->Detach();
 
   FOR_EACH_OBSERVER(Observer, observers_, WillDeleteShelf());
   Shell::GetInstance()->RemoveShellObserver(this);
   aura::client::GetActivationClient(root_window_)->RemoveObserver(this);
 }
 
 void ShelfLayoutManager::SetAutoHideBehavior(ShelfAutoHideBehavior behavior) {
   if (auto_hide_behavior_ == behavior)
     return;
   auto_hide_behavior_ = behavior;
   UpdateVisibilityState();
   FOR_EACH_OBSERVER(Observer, observers_,
                     OnAutoHideStateChanged(state_.auto_hide_state));
 }
 
 bool ShelfLayoutManager::IsVisible() const {
-  return status_->IsVisible() && (state_.visibility_state == VISIBLE ||
-      (state_.visibility_state == AUTO_HIDE &&
-       state_.auto_hide_state == AUTO_HIDE_SHOWN));
+  return status_area_widget_->IsVisible() &&
+      (state_.visibility_state == VISIBLE ||
+       (state_.visibility_state == AUTO_HIDE &&
+        state_.auto_hide_state == AUTO_HIDE_SHOWN));
 }
 
 void ShelfLayoutManager::SetLauncher(Launcher* launcher) {
   if (launcher == launcher_)
     return;
 
   launcher_ = launcher;
   if (launcher_)
     launcher_->SetAlignment(alignment_);
   LayoutShelf();
 }
 
 bool ShelfLayoutManager::SetAlignment(ShelfAlignment alignment) {
   if (alignment_ == alignment)
     return false;
 
   alignment_ = alignment;
   if (launcher_)
     launcher_->SetAlignment(alignment);
-  StatusAreaWidget* status_area_widget =
-      Shell::GetInstance()->status_area_widget();
-  if (status_area_widget)
-    Shell::GetInstance()->status_area_widget()->SetShelfAlignment(alignment);
+  status_area_widget_->SetShelfAlignment(alignment);
   LayoutShelf();
   return true;
 }
 
 gfx::Rect ShelfLayoutManager::GetIdealBounds() {
   // TODO(oshima): this is wrong. Figure out what display shelf is on
   // and everything should be based on it.
   gfx::Rect bounds(ScreenAsh::GetDisplayBoundsInParent(
-      status_->GetNativeView()));
+      status_area_widget_->GetNativeView()));
   int width = 0, height = 0;
   GetShelfSize(&width, &height);
   switch (alignment_) {
     case SHELF_ALIGNMENT_BOTTOM:
       return gfx::Rect(bounds.x(), bounds.bottom() - height,
                        bounds.width(), height);
     case SHELF_ALIGNMENT_LEFT:
       return gfx::Rect(bounds.x(), bounds.y(), width, bounds.height());
     case SHELF_ALIGNMENT_RIGHT:
       return gfx::Rect(bounds.right() - width, bounds.y(), width,
                        bounds.height());
   }
   NOTREACHED();
   return gfx::Rect();
 }
 
 void ShelfLayoutManager::LayoutShelf() {
   AutoReset<bool> auto_reset_in_layout(&in_layout_, true);
   StopAnimating();
   TargetBounds target_bounds;
   CalculateTargetBounds(state_, &target_bounds);
   if (launcher_widget()) {
     GetLayer(launcher_widget())->SetOpacity(target_bounds.opacity);
     launcher_->SetWidgetBounds(
         ScreenAsh::ConvertRectToScreen(
             launcher_widget()->GetNativeView()->parent(),
             target_bounds.launcher_bounds_in_root));
     launcher_->SetStatusSize(target_bounds.status_bounds_in_root.size());
   }
-  GetLayer(status_)->SetOpacity(target_bounds.opacity);
-  status_->SetBounds(
+  GetLayer(status_area_widget_)->SetOpacity(target_bounds.opacity);
+  status_area_widget_->SetBounds(
       ScreenAsh::ConvertRectToScreen(
-          status_->GetNativeView()->parent(),
+          status_area_widget_->GetNativeView()->parent(),
           target_bounds.status_bounds_in_root));
   Shell::GetInstance()->SetDisplayWorkAreaInsets(
       Shell::GetPrimaryRootWindow(),
       target_bounds.work_area_insets);
   UpdateHitTestBounds();
 }
 
 void ShelfLayoutManager::UpdateVisibilityState() {
   ShellDelegate* delegate = Shell::GetInstance()->delegate();
   if (delegate && delegate->IsScreenLocked()) {
@@ skipping 80 matching lines @@
   // Start reveling the status menu when:
   //   - dragging up on an already visible shelf
   //   - dragging up on a hidden shelf, but it is currently completely visible.
   if (horizontal && gesture.details().scroll_y() < 0) {
     int min_height = 0;
     if (gesture_drag_auto_hide_state_ == AUTO_HIDE_HIDDEN && launcher_widget())
       min_height = launcher_widget()->GetContentsView()->
           GetPreferredSize().height();
 
     if (min_height < launcher_widget()->GetWindowBoundsInScreen().height() &&
-        gesture.root_location().x() >= status_->GetWindowBoundsInScreen().x() &&
+        gesture.root_location().x() >=
+        status_area_widget_->GetWindowBoundsInScreen().x() &&
         IsDraggingTrayEnabled())
       return DRAG_TRAY;
   }
 
   return DRAG_SHELF;
 }
 
 void ShelfLayoutManager::CompleteGestureDrag(const ui::GestureEvent& gesture) {
   bool horizontal = alignment() == SHELF_ALIGNMENT_BOTTOM;
   bool should_change = false;
@@ skipping 26 matching lines @@
   if (!should_change) {
     CancelGestureDrag();
     return;
   }
 
   gesture_drag_auto_hide_state_ =
       gesture_drag_auto_hide_state_ == AUTO_HIDE_SHOWN ? AUTO_HIDE_HIDDEN :
                                                          AUTO_HIDE_SHOWN;
   if (launcher_widget())
     launcher_widget()->Deactivate();
-  status_->Deactivate();
+  status_area_widget_->Deactivate();
   if (gesture_drag_auto_hide_state_ == AUTO_HIDE_HIDDEN &&
       auto_hide_behavior_ != SHELF_AUTO_HIDE_BEHAVIOR_ALWAYS) {
     gesture_drag_status_ = GESTURE_DRAG_NONE;
     SetAutoHideBehavior(SHELF_AUTO_HIDE_BEHAVIOR_ALWAYS);
   } else if (gesture_drag_auto_hide_state_ == AUTO_HIDE_SHOWN &&
              auto_hide_behavior_ != SHELF_AUTO_HIDE_BEHAVIOR_NEVER) {
     gesture_drag_status_ = GESTURE_DRAG_NONE;
     SetAutoHideBehavior(SHELF_AUTO_HIDE_BEHAVIOR_NEVER);
   } else {
     gesture_drag_status_ = GESTURE_DRAG_COMPLETE_IN_PROGRESS;
     UpdateVisibilityState();
     gesture_drag_status_ = GESTURE_DRAG_NONE;
   }
 }
 
 void ShelfLayoutManager::CancelGestureDrag() {
   gesture_drag_status_ = GESTURE_DRAG_NONE;
   ui::ScopedLayerAnimationSettings
       launcher_settings(GetLayer(launcher_widget())->GetAnimator()),
-      status_settings(GetLayer(status_)->GetAnimator());
+      status_settings(GetLayer(status_area_widget_)->GetAnimator());
   LayoutShelf();
   UpdateVisibilityState();
   UpdateShelfBackground(internal::BackgroundAnimator::CHANGE_ANIMATE);
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // ShelfLayoutManager, aura::LayoutManager implementation:
 
 void ShelfLayoutManager::OnWindowResized() {
   LayoutShelf();
@@ skipping 12 matching lines @@
                                                         bool visible) {
 }
 
 void ShelfLayoutManager::SetChildBounds(aura::Window* child,
                                         const gfx::Rect& requested_bounds) {
   SetChildBoundsDirect(child, requested_bounds);
   // We may contain other widgets (such as frame maximize bubble) but they don't
   // effect the layout in anyway.
   if (!in_layout_ &&
       ((launcher_widget() && launcher_widget()->GetNativeView() == child) ||
-       (status_->GetNativeView() == child))) {
+       (status_area_widget_->GetNativeView() == child))) {
     LayoutShelf();
   }
 }
 
 void ShelfLayoutManager::OnLockStateChanged(bool locked) {
   UpdateVisibilityState();
 }
 
 void ShelfLayoutManager::OnWindowActivated(aura::Window* active,
                                            aura::Window* old_active) {
@@ skipping 56 matching lines @@
     ui::ScopedLayerAnimationSettings launcher_animation_setter(
         GetLayer(launcher_widget())->GetAnimator());
     launcher_animation_setter.SetTransitionDuration(
         base::TimeDelta::FromMilliseconds(kWorkspaceSwitchTimeMS));
     launcher_animation_setter.SetTweenType(ui::Tween::EASE_OUT);
     GetLayer(launcher_widget())->SetBounds(
         target_bounds.launcher_bounds_in_root);
     GetLayer(launcher_widget())->SetOpacity(target_bounds.opacity);
   }
   ui::ScopedLayerAnimationSettings status_animation_setter(
-      GetLayer(status_)->GetAnimator());
+      GetLayer(status_area_widget_)->GetAnimator());
   status_animation_setter.SetTransitionDuration(
       base::TimeDelta::FromMilliseconds(kWorkspaceSwitchTimeMS));
   status_animation_setter.SetTweenType(ui::Tween::EASE_OUT);
 
   // Delay updating the background when going from AUTO_HIDE_SHOWN to
   // AUTO_HIDE_HIDDEN until the shelf animates out. Otherwise during the
   // animation you see the background change.
   // Also delay the animation when the shelf was hidden, and has just been made
   // visible (e.g. using a gesture-drag).
   bool delay_shelf_update =
       state.visibility_state == AUTO_HIDE &&
       state.auto_hide_state == AUTO_HIDE_HIDDEN &&
       old_state.visibility_state == AUTO_HIDE;
 
   if (state.visibility_state == VISIBLE &&
       old_state.visibility_state == AUTO_HIDE &&
       old_state.auto_hide_state == AUTO_HIDE_HIDDEN)
     delay_shelf_update = true;
 
   if (delay_shelf_update) {
     if (update_shelf_observer_)
       update_shelf_observer_->Detach();
     // UpdateShelfBackground deletes itself when the animation is done.
     update_shelf_observer_ = new UpdateShelfObserver(this);
     status_animation_setter.AddObserver(update_shelf_observer_);
   }
-  GetLayer(status_)->SetBounds(target_bounds.status_bounds_in_root);
-  GetLayer(status_)->SetOpacity(target_bounds.opacity);
+  ui::Layer* layer = GetLayer(status_area_widget_);
+  layer->SetBounds(target_bounds.status_bounds_in_root);
+  layer->SetOpacity(target_bounds.opacity);
   Shell::GetInstance()->SetDisplayWorkAreaInsets(
       Shell::GetPrimaryRootWindow(),
       target_bounds.work_area_insets);
   UpdateHitTestBounds();
   if (!delay_shelf_update)
     UpdateShelfBackground(change_type);
 }
 
 void ShelfLayoutManager::StopAnimating() {
+  ui::Layer* layer = GetLayer(status_area_widget_);
   if (launcher_widget())
-    GetLayer(launcher_widget())->GetAnimator()->StopAnimating();
-  GetLayer(status_)->GetAnimator()->StopAnimating();
+    layer->GetAnimator()->StopAnimating();
+  layer->GetAnimator()->StopAnimating();
 }
 
 void ShelfLayoutManager::GetShelfSize(int* width, int* height) {
   *width = *height = 0;
-  gfx::Size status_size(status_->GetWindowBoundsInScreen().size());
+  gfx::Size status_size(status_area_widget_->GetWindowBoundsInScreen().size());
   gfx::Size launcher_size = launcher_ ?
       launcher_widget()->GetContentsView()->GetPreferredSize() : gfx::Size();
   if (alignment_ == SHELF_ALIGNMENT_BOTTOM)
     *height = std::max(launcher_size.height(), status_size.height());
   else
     *width = std::max(launcher_size.width(), status_size.width());
 }
 
 void ShelfLayoutManager::AdjustBoundsBasedOnAlignment(int inset,
                                                       gfx::Rect* bounds) const {
   switch (alignment_) {
     case SHELF_ALIGNMENT_BOTTOM:
       bounds->Inset(gfx::Insets(0, 0, inset, 0));
       break;
     case SHELF_ALIGNMENT_LEFT:
       bounds->Inset(gfx::Insets(0, inset, 0, 0));
       break;
     case SHELF_ALIGNMENT_RIGHT:
       bounds->Inset(gfx::Insets(0, 0, 0, inset));
       break;
   }
 }
 
 void ShelfLayoutManager::CalculateTargetBounds(
     const State& state,
     TargetBounds* target_bounds) {
-  const gfx::Rect& available_bounds(
-      status_->GetNativeView()->GetRootWindow()->bounds());
-  gfx::Rect status_size(status_->GetWindowBoundsInScreen().size());
+  const gfx::Rect& available_bounds(root_window_->bounds());
+  gfx::Rect status_size(status_area_widget_->GetWindowBoundsInScreen().size());
   gfx::Size launcher_size = launcher_ ?
       launcher_widget()->GetContentsView()->GetPreferredSize() : gfx::Size();
   int shelf_size = 0;
   int shelf_width = 0, shelf_height = 0;
   GetShelfSize(&shelf_width, &shelf_height);
   if (state.visibility_state == VISIBLE ||
       (state.visibility_state == AUTO_HIDE &&
        state.auto_hide_state == AUTO_HIDE_SHOWN)) {
     shelf_size = std::max(shelf_width, shelf_height);
   } else if (state.visibility_state == AUTO_HIDE &&
@@ skipping 139 matching lines @@
   }
 }
 
 void ShelfLayoutManager::UpdateShelfBackground(
     BackgroundAnimator::ChangeType type) {
   bool launcher_paints = GetLauncherPaintsBackground();
   if (launcher_)
     launcher_->SetPaintsBackground(launcher_paints, type);
   // The status area normally draws a background, but we don't want it to draw a
   // background when the launcher does or when we're at login/lock screen.
-  StatusAreaWidget* status_area_widget =
-      Shell::GetInstance()->status_area_widget();
-  if (status_area_widget) {
-    ShellDelegate* delegate = Shell::GetInstance()->delegate();
-    bool delegate_allows_tray_bg = !delegate ||
-        (delegate->IsUserLoggedIn() && !delegate->IsScreenLocked());
-    bool status_area_paints = !launcher_paints && delegate_allows_tray_bg;
-    status_area_widget->SetPaintsBackground(status_area_paints, type);
-  }
+  ShellDelegate* delegate = Shell::GetInstance()->delegate();
+  bool delegate_allows_tray_bg = !delegate ||
+      (delegate->IsUserLoggedIn() && !delegate->IsScreenLocked());
+  bool status_area_paints = !launcher_paints && delegate_allows_tray_bg;
+  status_area_widget_->SetPaintsBackground(status_area_paints, type);
 }
 
 bool ShelfLayoutManager::GetLauncherPaintsBackground() const {
   return gesture_drag_status_ != GESTURE_DRAG_NONE ||
       (!state_.is_screen_locked && window_overlaps_shelf_) ||
       (state_.visibility_state == AUTO_HIDE) ;
 }
 
 void ShelfLayoutManager::UpdateAutoHideStateNow() {
   SetState(state_.visibility_state);
 }
 
 ShelfLayoutManager::AutoHideState ShelfLayoutManager::CalculateAutoHideState(
     VisibilityState visibility_state) const {
   if (visibility_state != AUTO_HIDE || !launcher_widget())
     return AUTO_HIDE_HIDDEN;
 
   if (gesture_drag_status_ == GESTURE_DRAG_COMPLETE_IN_PROGRESS)
     return gesture_drag_auto_hide_state_;
 
   Shell* shell = Shell::GetInstance();
   if (shell->GetAppListTargetVisibility())
     return AUTO_HIDE_SHOWN;
 
-  if (shell->status_area_widget() &&
-      shell->status_area_widget()->ShouldShowLauncher())
+  if (status_area_widget_ && status_area_widget_->ShouldShowLauncher())
     return AUTO_HIDE_SHOWN;
 
   if (launcher_ && launcher_->IsShowingMenu())
     return AUTO_HIDE_SHOWN;
 
   if (launcher_ && launcher_->IsShowingOverflowBubble())
     return AUTO_HIDE_SHOWN;
 
-  if (launcher_widget()->IsActive() || status_->IsActive())
+  if (launcher_widget()->IsActive() || status_area_widget_->IsActive())
     return AUTO_HIDE_SHOWN;
 
   // Don't show if the user is dragging the mouse.
   if (event_filter_.get() && event_filter_->in_mouse_drag())
     return AUTO_HIDE_HIDDEN;
 
   gfx::Rect shelf_region = launcher_widget()->GetWindowBoundsInScreen();
-  if (shell->status_area_widget() &&
-      shell->status_area_widget()->IsMessageBubbleShown() &&
+  if (status_area_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.
     shelf_region.Inset(alignment_ == SHELF_ALIGNMENT_RIGHT ?
                            -kNotificationBubbleGapHeight : 0,
                        alignment_ == SHELF_ALIGNMENT_BOTTOM ?
                            -kNotificationBubbleGapHeight : 0,
                        alignment_ == SHELF_ALIGNMENT_LEFT ?
                            -kNotificationBubbleGapHeight : 0,
                        0);
@@ skipping 18 matching lines @@
         break;
       case SHELF_ALIGNMENT_RIGHT:
         insets.Set(0, kWorkspaceAreaBottomInset, 0, 0);
         break;
     }
   }
   if (launcher_widget() && launcher_widget()->GetNativeWindow()) {
     launcher_widget()->GetNativeWindow()->SetHitTestBoundsOverrideOuter(
         insets, 1);
   }
-  status_->GetNativeWindow()->SetHitTestBoundsOverrideOuter( insets, 1);
+  status_area_widget_->GetNativeWindow()->
+      SetHitTestBoundsOverrideOuter(insets, 1);
 }
 
 bool ShelfLayoutManager::IsShelfWindow(aura::Window* window) {
   if (!window)
     return false;
   return (launcher_widget() &&
           launcher_widget()->GetNativeWindow()->Contains(window)) ||
-      (status_ && status_->GetNativeWindow()->Contains(window));
+      (status_area_widget_->GetNativeWindow()->Contains(window));
 }
 
 int ShelfLayoutManager::GetWorkAreaSize(const State& state, int size) const {
   if (state.visibility_state == VISIBLE)
     return size;
   if (state.visibility_state == AUTO_HIDE)
     return kAutoHideSize;
   return 0;
 }
 
 }  // namespace internal
 }  // namespace ash