Cleanup shelf initialization and observation.

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 169 matching lines @@
 
   DISALLOW_COPY_AND_ASSIGN(UpdateShelfObserver);
 };
 
 // ShelfLayoutManager ----------------------------------------------------------
 
 ShelfLayoutManager::ShelfLayoutManager(ShelfWidget* shelf)
     : SnapToPixelLayoutManager(shelf->GetNativeView()->parent()),
       root_window_(shelf->GetNativeView()->GetRootWindow()),
       updating_bounds_(false),
-      auto_hide_behavior_(SHELF_AUTO_HIDE_BEHAVIOR_NEVER),
-      alignment_(SHELF_ALIGNMENT_BOTTOM),
       shelf_(shelf),
       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) {
   Shell::GetInstance()->AddShellObserver(this);
   Shell::GetInstance()->lock_state_controller()->AddObserver(this);
   aura::client::GetActivationClient(root_window_)->AddObserver(this);
   Shell::GetInstance()->session_state_delegate()->AddSessionStateObserver(this);
 }
 
 ShelfLayoutManager::~ShelfLayoutManager() {
   if (update_shelf_observer_)
     update_shelf_observer_->Detach();
 
   FOR_EACH_OBSERVER(ShelfLayoutManagerObserver, observers_, WillDeleteShelf());
   Shell::GetInstance()->RemoveShellObserver(this);
   Shell::GetInstance()->lock_state_controller()->RemoveObserver(this);
   Shell::GetInstance()->
       session_state_delegate()->RemoveSessionStateObserver(this);
 }
 
-void ShelfLayoutManager::SetAutoHideBehavior(ShelfAutoHideBehavior behavior) {
-  if (auto_hide_behavior_ == behavior)
-    return;
-  auto_hide_behavior_ = behavior;
-  UpdateVisibilityState();
-  FOR_EACH_OBSERVER(ShelfLayoutManagerObserver, observers_,
-                    OnAutoHideBehaviorChanged(root_window_,
-                                              auto_hide_behavior_));
-}
-
 void ShelfLayoutManager::PrepareForShutdown() {
   // 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);
 }
 
 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));
 }
 
-void ShelfLayoutManager::SetAlignment(ShelfAlignment alignment) {
-  if (alignment_ == alignment)
-    return;
-
-  alignment_ = alignment;
-  // The shelf will itself move to the bottom while locked or obscured by user
-  // login. If a request is sent to move while being obscured, we postpone the
-  // move until the user session is resumed.
-  if (!IsAlignmentLocked()) {
-    shelf_->SetAlignment(alignment);
-    LayoutShelf();
-    Shell::GetInstance()->OnShelfAlignmentChanged(
-        shelf_->GetNativeWindow()->GetRootWindow());
-  }
-}
-
-ShelfAlignment ShelfLayoutManager::GetAlignment() const {
-  // When the screen is locked or a user gets added, the shelf is forced into
-  // bottom alignment.
-  if (IsAlignmentLocked())
-    return SHELF_ALIGNMENT_BOTTOM;
-  return alignment_;
-}
-
 gfx::Rect ShelfLayoutManager::GetIdealBounds() {
   gfx::Rect rect(ScreenUtil::GetDisplayBoundsInParent(shelf_->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()));
 }
 
 void ShelfLayoutManager::LayoutShelf() {
-  TargetBounds target_bounds;
-  CalculateTargetBounds(state_, &target_bounds);
-  UpdateBoundsAndOpacity(target_bounds, false, NULL);
+  if (shelf_->shelf()) {
+    TargetBounds target_bounds;
+    CalculateTargetBounds(state_, &target_bounds);
+    UpdateBoundsAndOpacity(target_bounds, false, NULL);
 
-  if (shelf_->shelf()) {
     // Update insets in ShelfWindowTargeter when shelf bounds change.
     FOR_EACH_OBSERVER(ShelfLayoutManagerObserver, observers_,
                       WillChangeVisibilityState(visibility_state()));
   }
 }
 
 ShelfVisibilityState ShelfLayoutManager::CalculateShelfVisibility() {
-  switch(auto_hide_behavior_) {
+  switch (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.
-  if (!workspace_controller_)
+  // during shutdown after PrepareForShutdown. Also bail before a shelf exists.
+  if (!workspace_controller_ || !shelf_->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.
     WorkspaceWindowState window_state(workspace_controller_->GetWindowState());
     switch (window_state) {
       case WORKSPACE_WINDOW_STATE_FULL_SCREEN: {
@@ skipping 139 matching lines @@
       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)
+  if (auto_hide_behavior() != new_auto_hide_behavior)
     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;
@@ skipping 23 matching lines @@
   }
 }
 
 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();
 }
 
+void ShelfLayoutManager::OnShelfAlignmentChanged(aura::Window* root_window) {
+  LayoutShelf();
+}
+
+void ShelfLayoutManager::OnShelfAutoHideBehaviorChanged(
+    aura::Window* root_window) {
+  UpdateVisibilityState();
+}
+
 void ShelfLayoutManager::OnWindowActivated(
     aura::client::ActivationChangeObserver::ActivationReason reason,
     aura::Window* gained_active,
     aura::Window* lost_active) {
   UpdateAutoHideStateNow();
 }
 
 bool ShelfLayoutManager::IsHorizontalAlignment() const {
   return GetAlignment() == SHELF_ALIGNMENT_BOTTOM;
 }
 
+bool ShelfLayoutManager::IsAlignmentLocked() const {
+  if (state_.is_screen_locked)
+    return true;
+  // The session state becomes active at the start of transitioning to a user
+  // session, however the session is considered blocked until the full UI is
+  // ready. Exit early to allow for proper layout.
+  SessionStateDelegate* session_state_delegate =
+      Shell::GetInstance()->session_state_delegate();
+  if (session_state_delegate->GetSessionState() ==
+      SessionStateDelegate::SESSION_STATE_ACTIVE) {
+    return false;
+  }
+  if (session_state_delegate->IsUserSessionBlocked() ||
+      state_.is_adding_user_screen) {
+    return true;
+  }
+  return false;
+}
+
 void ShelfLayoutManager::SetChromeVoxPanelHeight(int height) {
   chromevox_panel_height_ = height;
   LayoutShelf();
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // ShelfLayoutManager, private:
 
 ShelfLayoutManager::TargetBounds::TargetBounds()
     : opacity(0.0f), status_opacity(0.0f) {}
@@ skipping 583 matching lines @@
     UpdateShelfVisibilityAfterLoginUIChange();
     return;
   }
   TargetBounds target_bounds;
   CalculateTargetBounds(state_, &target_bounds);
   UpdateBoundsAndOpacity(target_bounds, true, NULL);
   UpdateVisibilityState();
 }
 
 void ShelfLayoutManager::UpdateShelfVisibilityAfterLoginUIChange() {
-  shelf_->SetAlignment(GetAlignment());
   UpdateVisibilityState();
   LayoutShelf();
+  // The shelf alignment may have changed when it was unlocked.
   Shell::GetInstance()->OnShelfAlignmentChanged(
       shelf_->GetNativeWindow()->GetRootWindow());
 }
 
-bool ShelfLayoutManager::IsAlignmentLocked() const {
-  if (state_.is_screen_locked)
-    return true;
-  // The session state becomes active at the start of transitioning to a user
-  // session, however the session is considered blocked until the full UI is
-  // ready. Exit early to allow for proper layout.
-  SessionStateDelegate* session_state_delegate =
-      Shell::GetInstance()->session_state_delegate();
-  if (session_state_delegate->GetSessionState() ==
-      SessionStateDelegate::SESSION_STATE_ACTIVE) {
-    return false;
-  }
-  if (session_state_delegate->IsUserSessionBlocked() ||
-      state_.is_adding_user_screen) {
-    return true;
-  }
-  return false;
-}
-
 }  // namespace ash