ash: Fix variable names and setters in ShelfLayoutManager and tests

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>
@@ skipping 193 matching lines @@
   }
 
  private:
   ShelfLayoutManager* shelf_layout_manager_;
 
   DISALLOW_COPY_AND_ASSIGN(RootWindowControllerObserverImpl);
 };
 
 // ShelfLayoutManager ----------------------------------------------------------
 
-ShelfLayoutManager::ShelfLayoutManager(ShelfWidget* shelf)
-    : SnapToPixelLayoutManager(shelf->GetNativeView()->parent()),
-      root_window_(shelf->GetNativeView()->GetRootWindow()),
+ShelfLayoutManager::ShelfLayoutManager(ShelfWidget* shelf_widget)
+    : SnapToPixelLayoutManager(shelf_widget->GetNativeView()->parent()),
+      root_window_(shelf_widget->GetNativeView()->GetRootWindow()),
       updating_bounds_(false),
-      shelf_(shelf),
+      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) {
@@ skipping 35 matching lines @@
   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);
 }
 
 bool ShelfLayoutManager::IsVisible() const {
   // status_area_widget() may be NULL during the shutdown.
-  return shelf_->status_area_widget() &&
-      shelf_->status_area_widget()->IsVisible() &&
-      (state_.visibility_state == SHELF_VISIBLE ||
-       (state_.visibility_state == SHELF_AUTO_HIDE &&
-        state_.auto_hide_state == SHELF_AUTO_HIDE_SHOWN));
+  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));
 }
 
 gfx::Rect ShelfLayoutManager::GetIdealBounds() {
-  gfx::Rect rect(ScreenUtil::GetDisplayBoundsInParent(shelf_->GetNativeView()));
+  gfx::Rect rect(
+      ScreenUtil::GetDisplayBoundsInParent(shelf_widget_->GetNativeView()));
   return SelectValueForShelfAlignment(
       gfx::Rect(rect.x(), rect.bottom() - kShelfSize, rect.width(), kShelfSize),
       gfx::Rect(rect.x(), rect.y(), kShelfSize, rect.height()),
       gfx::Rect(rect.right() - kShelfSize, rect.y(), kShelfSize,
                 rect.height()));
 }
 
 gfx::Size ShelfLayoutManager::GetPreferredSize() {
   TargetBounds target_bounds;
   CalculateTargetBounds(state_, &target_bounds);
   return target_bounds.shelf_bounds_in_root.size();
 }
 
 void ShelfLayoutManager::LayoutShelf() {
   TargetBounds target_bounds;
   CalculateTargetBounds(state_, &target_bounds);
   UpdateBoundsAndOpacity(target_bounds, false, NULL);
 
   // Update insets in ShelfWindowTargeter when shelf bounds change.
   FOR_EACH_OBSERVER(ShelfLayoutManagerObserver, observers_,
                     WillChangeVisibilityState(visibility_state()));
 }
 
 ShelfVisibilityState ShelfLayoutManager::CalculateShelfVisibility() {
-  switch (auto_hide_behavior()) {
+  switch (shelf_widget_->shelf()->auto_hide_behavior()) {
     case SHELF_AUTO_HIDE_BEHAVIOR_ALWAYS:
       return SHELF_AUTO_HIDE;
     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 when there is no |workspace_controller_|, which happens
   // during shutdown after PrepareForShutdown. Also bail before a shelf exists.
-  if (!workspace_controller_ || !shelf_->shelf())
+  if (!workspace_controller_ || !shelf_widget_->shelf())
     return;
 
   if (state_.is_screen_locked || state_.is_adding_user_screen) {
     SetState(SHELF_VISIBLE);
   } 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) {
@@ skipping 28 matching lines @@
 void ShelfLayoutManager::UpdateAutoHideState() {
   ShelfAutoHideState auto_hide_state =
       CalculateAutoHideState(state_.visibility_state);
   if (auto_hide_state != state_.auto_hide_state) {
     if (auto_hide_state == SHELF_AUTO_HIDE_HIDDEN) {
       // Hides happen immediately.
       SetState(state_.visibility_state);
     } else {
       if (!auto_hide_timer_.IsRunning()) {
         mouse_over_shelf_when_auto_hide_timer_started_ =
-            shelf_->GetWindowBoundsInScreen().Contains(
+            shelf_widget_->GetWindowBoundsInScreen().Contains(
                 display::Screen::GetScreen()->GetCursorScreenPoint());
       }
       auto_hide_timer_.Start(
           FROM_HERE,
           base::TimeDelta::FromMilliseconds(kAutoHideDelayMS),
           this, &ShelfLayoutManager::UpdateAutoHideStateNow);
     }
   } else {
     StopAutoHideTimer();
   }
@@ skipping 101 matching lines @@
                                        gesture.details().velocity_x() < 0);
     }
   } else {
     NOTREACHED();
   }
 
   if (!should_change) {
     CancelGestureDrag();
     return;
   }
-  if (shelf_) {
-    shelf_->Deactivate();
-    shelf_->status_area_widget()->Deactivate();
+  if (shelf_widget_) {
+    shelf_widget_->Deactivate();
+    shelf_widget_->status_area_widget()->Deactivate();
   }
   gesture_drag_auto_hide_state_ =
       gesture_drag_auto_hide_state_ == SHELF_AUTO_HIDE_SHOWN ?
       SHELF_AUTO_HIDE_HIDDEN : SHELF_AUTO_HIDE_SHOWN;
   ShelfAutoHideBehavior new_auto_hide_behavior =
       gesture_drag_auto_hide_state_ == SHELF_AUTO_HIDE_SHOWN ?
       SHELF_AUTO_HIDE_BEHAVIOR_NEVER : SHELF_AUTO_HIDE_BEHAVIOR_ALWAYS;
 
   // When in fullscreen and the shelf is forced to be auto hidden, the auto hide
   // behavior affects neither the visibility state nor the auto hide state. Set
   // |gesture_drag_status_| to GESTURE_DRAG_COMPLETE_IN_PROGRESS to set the auto
   // hide state to |gesture_drag_auto_hide_state_|.
   gesture_drag_status_ = GESTURE_DRAG_COMPLETE_IN_PROGRESS;
-  if (auto_hide_behavior() != new_auto_hide_behavior)
-    SetAutoHideBehavior(new_auto_hide_behavior);
+  Shelf* shelf = shelf_widget_->shelf();
+  if (shelf->auto_hide_behavior() != new_auto_hide_behavior)
+    shelf->SetAutoHideBehavior(new_auto_hide_behavior);
   else
     UpdateVisibilityState();
   gesture_drag_status_ = GESTURE_DRAG_NONE;
 }
 
 void ShelfLayoutManager::CancelGestureDrag() {
   gesture_drag_status_ = GESTURE_DRAG_CANCEL_IN_PROGRESS;
   UpdateVisibilityState();
   gesture_drag_status_ = GESTURE_DRAG_NONE;
 }
 
 void ShelfLayoutManager::SetAnimationDurationOverride(
     int duration_override_in_ms) {
   duration_override_in_ms_ = duration_override_in_ms;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // ShelfLayoutManager, aura::LayoutManager implementation:
 
 void ShelfLayoutManager::OnWindowResized() {
   LayoutShelf();
 }
 
 void ShelfLayoutManager::SetChildBounds(aura::Window* child,
                                         const gfx::Rect& requested_bounds) {
   SnapToPixelLayoutManager::SetChildBounds(child, requested_bounds);
   // We may contain other widgets (such as frame maximize bubble) but they don't
   // effect the layout in anyway.
   if (!updating_bounds_ &&
-      ((shelf_->GetNativeView() == child) ||
-       (shelf_->status_area_widget()->GetNativeView() == child))) {
+      ((shelf_widget_->GetNativeView() == child) ||
+       (shelf_widget_->status_area_widget()->GetNativeView() == child))) {
     LayoutShelf();
   }
 }
 
 void ShelfLayoutManager::OnLockStateChanged(bool locked) {
   // Force the shelf to layout for alignment (bottom if locked, restore
   // the previous alignment otherwise).
   state_.is_screen_locked = locked;
   UpdateShelfVisibilityAfterLoginUIChange();
 }
@@ skipping 26 matching lines @@
 
 ////////////////////////////////////////////////////////////////////////////////
 // ShelfLayoutManager, private:
 
 ShelfLayoutManager::TargetBounds::TargetBounds()
     : opacity(0.0f), status_opacity(0.0f) {}
 
 ShelfLayoutManager::TargetBounds::~TargetBounds() {}
 
 void ShelfLayoutManager::SetState(ShelfVisibilityState visibility_state) {
-  if (!shelf_->GetNativeView())
+  if (!shelf_widget_->GetNativeView())
     return;
 
   State state;
   state.visibility_state = visibility_state;
   state.auto_hide_state = CalculateAutoHideState(visibility_state);
   state.window_state = workspace_controller_
                            ? workspace_controller_->GetWindowState()
                            : wm::WORKSPACE_WINDOW_STATE_DEFAULT;
   // Preserve the log in screen states.
   state.is_adding_user_screen = state_.is_adding_user_screen;
@@ skipping 53 matching lines @@
 
   if (delay_background_change) {
     if (update_shelf_observer_)
       update_shelf_observer_->Detach();
     // UpdateShelfBackground deletes itself when the animation is done.
     update_shelf_observer_ = new UpdateShelfObserver(this);
   } else {
     UpdateShelfBackground(change_type);
   }
 
-  shelf_->SetDimsShelf(state.visibility_state == SHELF_VISIBLE &&
-                       state.window_state ==
-                           wm::WORKSPACE_WINDOW_STATE_MAXIMIZED);
+  shelf_widget_->SetDimsShelf(state.visibility_state == SHELF_VISIBLE &&
+                              state.window_state ==
+                                  wm::WORKSPACE_WINDOW_STATE_MAXIMIZED);
 
   TargetBounds target_bounds;
   CalculateTargetBounds(state_, &target_bounds);
   UpdateBoundsAndOpacity(target_bounds, true,
       delay_background_change ? update_shelf_observer_ : NULL);
 
   // The delegate must be notified after |state_| is updated so that it can
   // query the new target bounds.
   ShelfDelegate* shelf_delegate = Shell::GetInstance()->GetShelfDelegate();
   if (old_state.visibility_state != state_.visibility_state)
-    shelf_delegate->OnShelfVisibilityStateChanged(shelf_->shelf());
+    shelf_delegate->OnShelfVisibilityStateChanged(shelf_widget_->shelf());
 
   // OnAutoHideStateChanged Should be emitted when:
   //  - firstly state changed to auto-hide from other state
   //  - or, auto_hide_state has changed
   if ((old_state.visibility_state != state_.visibility_state &&
        state_.visibility_state == SHELF_AUTO_HIDE) ||
       old_state.auto_hide_state != state_.auto_hide_state) {
-    shelf_delegate->OnShelfAutoHideStateChanged(shelf_->shelf());
+    shelf_delegate->OnShelfAutoHideStateChanged(shelf_widget_->shelf());
     FOR_EACH_OBSERVER(ShelfLayoutManagerObserver, observers_,
                       OnAutoHideStateChanged(state_.auto_hide_state));
   }
 }
 
 void ShelfLayoutManager::UpdateBoundsAndOpacity(
     const TargetBounds& target_bounds,
     bool animate,
     ui::ImplicitAnimationObserver* observer) {
   base::AutoReset<bool> auto_reset_updating_bounds(&updating_bounds_, true);
   {
     ui::ScopedLayerAnimationSettings shelf_animation_setter(
-        GetLayer(shelf_)->GetAnimator());
+        GetLayer(shelf_widget_)->GetAnimator());
     ui::ScopedLayerAnimationSettings status_animation_setter(
-        GetLayer(shelf_->status_area_widget())->GetAnimator());
+        GetLayer(shelf_widget_->status_area_widget())->GetAnimator());
     if (animate) {
       int duration = duration_override_in_ms_ ? duration_override_in_ms_ :
                                                 kCrossFadeDurationMS;
       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_)->SetOpacity(target_bounds.opacity);
+    GetLayer(shelf_widget_)->SetOpacity(target_bounds.opacity);
     // mash::wm::ShelfLayout manages window bounds when running in mash.
     if (!Shell::GetInstance()->in_mus()) {
-      shelf_->SetBounds(ScreenUtil::ConvertRectToScreen(
-          shelf_->GetNativeView()->parent(),
+      shelf_widget_->SetBounds(ScreenUtil::ConvertRectToScreen(
+          shelf_widget_->GetNativeView()->parent(),
           target_bounds.shelf_bounds_in_root));
     }
 
-    GetLayer(shelf_->status_area_widget())->SetOpacity(
-        target_bounds.status_opacity);
+    GetLayer(shelf_widget_->status_area_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_->status_area_widget()->Hide();
+      shelf_widget_->status_area_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());
     // mash::wm::ShelfLayout manages window bounds when running mash.
     if (!Shell::GetInstance()->in_mus()) {
-      shelf_->status_area_widget()->SetBounds(
+      shelf_widget_->status_area_widget()->SetBounds(
           ScreenUtil::ConvertRectToScreen(
-              shelf_->status_area_widget()->GetNativeView()->parent(),
+              shelf_widget_->status_area_widget()->GetNativeView()->parent(),
               status_bounds));
     }
     if (!state_.is_screen_locked) {
       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_.is_adding_user_screen || !keyboard_bounds_.IsEmpty())
         insets = target_bounds.work_area_insets;
       Shell::GetInstance()->SetDisplayWorkAreaInsets(root_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_->GetContentsView()->SetBorder(views::Border::CreateEmptyBorder(
+  shelf_widget_->GetContentsView()->SetBorder(views::Border::CreateEmptyBorder(
       shelf_bounds.InsetsFrom(target_bounds.shelf_bounds_in_shelf)));
-  shelf_->GetContentsView()->Layout();
+  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_->status_area_widget()->Show();
+    shelf_widget_->status_area_widget()->Show();
 }
 
 void ShelfLayoutManager::StopAnimating() {
-  GetLayer(shelf_)->GetAnimator()->StopAnimating();
-  GetLayer(shelf_->status_area_widget())->GetAnimator()->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;
   if (state.visibility_state == SHELF_AUTO_HIDE &&
       state.auto_hide_state == SHELF_AUTO_HIDE_HIDDEN) {
     // Auto-hidden shelf always starts with the default size. If a gesture-drag
     // is in progress, then the call to UpdateTargetBoundsForGesture() below
     // takes care of setting the height properly.
@@ skipping 15 matching lines @@
     bottom_shelf_vertical_offset -= keyboard_bounds_.height();
 
   gfx::Point shelf_origin = SelectValueForShelfAlignment(
       gfx::Point(available_bounds.x(), bottom_shelf_vertical_offset),
       gfx::Point(available_bounds.x(), available_bounds.y()),
       gfx::Point(available_bounds.right() - shelf_width, available_bounds.y()));
   target_bounds->shelf_bounds_in_root =
       gfx::Rect(shelf_origin.x(), shelf_origin.y(), shelf_width, shelf_height);
 
   gfx::Size status_size(
-      shelf_->status_area_widget()->GetWindowBoundsInScreen().size());
+      shelf_widget_->status_area_widget()->GetWindowBoundsInScreen().size());
   if (IsHorizontalAlignment())
     status_size.set_height(kShelfSize);
   else
     status_size.set_width(kShelfSize);
 
   gfx::Point status_origin = SelectValueForShelfAlignment(
       gfx::Point(0, 0),
       gfx::Point(shelf_width - status_size.width(),
                  shelf_height - status_size.height()),
       gfx::Point(0, shelf_height - status_size.height()));
@@ skipping 125 matching lines @@
     else
       target_bounds->status_bounds_in_shelf.set_x(
           target_bounds->shelf_bounds_in_root.width() -
           kShelfSize);
   }
 }
 
 void ShelfLayoutManager::UpdateShelfBackground(
     BackgroundAnimatorChangeType type) {
   const wm::ShelfBackgroundType background_type(GetShelfBackgroundType());
-  shelf_->SetPaintsBackground(background_type, type);
+  shelf_widget_->SetPaintsBackground(background_type, type);
   FOR_EACH_OBSERVER(ShelfLayoutManagerObserver, observers_,
                     OnBackgroundUpdated(background_type, type));
 }
 
 wm::ShelfBackgroundType ShelfLayoutManager::GetShelfBackgroundType() const {
   if (state_.visibility_state != SHELF_AUTO_HIDE &&
       state_.window_state == wm::WORKSPACE_WINDOW_STATE_MAXIMIZED) {
     return wm::SHELF_BACKGROUND_MAXIMIZED;
   }
 
@@ skipping 13 matching lines @@
   // If the state did not change, the auto hide timer may still be running.
   StopAutoHideTimer();
 }
 
 void ShelfLayoutManager::StopAutoHideTimer() {
   auto_hide_timer_.Stop();
   mouse_over_shelf_when_auto_hide_timer_started_ = false;
 }
 
 gfx::Rect ShelfLayoutManager::GetAutoHideShowShelfRegionInScreen() const {
-  gfx::Rect shelf_bounds_in_screen = shelf_->GetWindowBoundsInScreen();
+  gfx::Rect shelf_bounds_in_screen = shelf_widget_->GetWindowBoundsInScreen();
   gfx::Vector2d offset = SelectValueForShelfAlignment(
       gfx::Vector2d(0, shelf_bounds_in_screen.height()),
       gfx::Vector2d(-kMaxAutoHideShowShelfRegionSize, 0),
       gfx::Vector2d(shelf_bounds_in_screen.width(), 0));
 
   gfx::Rect show_shelf_region_in_screen = shelf_bounds_in_screen;
   show_shelf_region_in_screen += offset;
   if (IsHorizontalAlignment())
     show_shelf_region_in_screen.set_height(kMaxAutoHideShowShelfRegionSize);
   else
     show_shelf_region_in_screen.set_width(kMaxAutoHideShowShelfRegionSize);
 
   // TODO: Figure out if we need any special handling when the keyboard is
   // visible.
   return show_shelf_region_in_screen;
 }
 
 ShelfAutoHideState ShelfLayoutManager::CalculateAutoHideState(
     ShelfVisibilityState visibility_state) const {
-  if (visibility_state != SHELF_AUTO_HIDE || !shelf_ || !shelf_->shelf())
+  if (visibility_state != SHELF_AUTO_HIDE || !shelf_widget_ ||
+      !shelf_widget_->shelf())
     return SHELF_AUTO_HIDE_HIDDEN;
 
   Shell* shell = Shell::GetInstance();
   // Unhide the shelf only on the active screen when the AppList is shown
   // (crbug.com/312445).
   if (shell->GetAppListTargetVisibility()) {
     aura::Window* active_window = wm::GetActiveWindow();
-    aura::Window* shelf_window = shelf_->GetNativeWindow();
+    aura::Window* shelf_window = shelf_widget_->GetNativeWindow();
     if (active_window && shelf_window &&
         active_window->GetRootWindow() == shelf_window->GetRootWindow()) {
       return SHELF_AUTO_HIDE_SHOWN;
     }
   }
 
-  if (shelf_->status_area_widget() &&
-      shelf_->status_area_widget()->ShouldShowShelf())
+  if (shelf_widget_->status_area_widget() &&
+      shelf_widget_->status_area_widget()->ShouldShowShelf())
     return SHELF_AUTO_HIDE_SHOWN;
 
-  if (shelf_->shelf() && shelf_->shelf()->IsShowingMenu())
+  if (shelf_widget_->shelf() && shelf_widget_->shelf()->IsShowingMenu())
     return SHELF_AUTO_HIDE_SHOWN;
 
-  if (shelf_->shelf() && shelf_->shelf()->IsShowingOverflowBubble())
+  if (shelf_widget_->shelf() &&
+      shelf_widget_->shelf()->IsShowingOverflowBubble())
     return SHELF_AUTO_HIDE_SHOWN;
 
-  if (shelf_->IsActive() ||
-      (shelf_->status_area_widget() &&
-       shelf_->status_area_widget()->IsActive()))
+  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<aura::Window*> windows =
         shell->mru_window_tracker()->BuildWindowListIgnoreModal();
 
     // Process the window list and check if there are any visible windows.
     bool visible_window = false;
     for (size_t i = 0; i < windows.size(); ++i) {
@@ skipping 11 matching lines @@
 
   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_->GetNativeWindow()->GetRootWindow());
+      shelf_widget_->GetNativeWindow()->GetRootWindow());
   if (!cursor_client->IsMouseEventsEnabled())
     return SHELF_AUTO_HIDE_HIDDEN;
 
-  gfx::Rect shelf_region = shelf_->GetWindowBoundsInScreen();
-  if (shelf_->status_area_widget() &&
-      shelf_->status_area_widget()->IsMessageBubbleShown() &&
+  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.
     wm::ShelfAlignment alignment = GetAlignment();
     shelf_region.Inset(
         alignment == wm::SHELF_ALIGNMENT_RIGHT ? -kNotificationBubbleGapHeight
                                                : 0,
         IsHorizontalAlignment() ? -kNotificationBubbleGapHeight : 0,
         alignment == wm::SHELF_ALIGNMENT_LEFT ? -kNotificationBubbleGapHeight
                                               : 0,
@@ skipping 23 matching lines @@
           cursor_position_in_screen)) {
     return SHELF_AUTO_HIDE_SHOWN;
   }
 
   return SHELF_AUTO_HIDE_HIDDEN;
 }
 
 bool ShelfLayoutManager::IsShelfWindow(aura::Window* window) {
   if (!window)
     return false;
-  return (shelf_ && shelf_->GetNativeWindow()->Contains(window)) ||
-      (shelf_->status_area_widget() &&
-       shelf_->status_area_widget()->GetNativeWindow()->Contains(window));
+  return (shelf_widget_ &&
+          shelf_widget_->GetNativeWindow()->Contains(window)) ||
+         (shelf_widget_->status_area_widget() &&
+          shelf_widget_->status_area_widget()->GetNativeWindow()->Contains(
+              window));
 }
 
 int ShelfLayoutManager::GetWorkAreaSize(const State& state, int size) const {
   if (state.visibility_state == SHELF_VISIBLE)
     return size;
   if (state.visibility_state == SHELF_AUTO_HIDE)
     return kAutoHideSize;
   return 0;
 }
 
@@ skipping 55 matching lines @@
   UpdateBoundsAndOpacity(target_bounds, true, NULL);
   UpdateVisibilityState();
 }
 
 void ShelfLayoutManager::UpdateShelfVisibilityAfterLoginUIChange() {
   UpdateVisibilityState();
   LayoutShelf();
 }
 
 }  // namespace ash