Sets the background color of shelf is opaque black when maximized (2nd)

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 198 matching lines @@
   if (auto_hide_behavior_ == behavior)
     return;
   auto_hide_behavior_ = behavior;
   UpdateVisibilityState();
   FOR_EACH_OBSERVER(ShelfLayoutManagerObserver, observers_,
                     OnAutoHideStateChanged(state_.auto_hide_state));
   FOR_EACH_OBSERVER(ShelfLayoutManagerObserver, observers_,
                     OnAutoHideBehaviorChanged(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();
+}
+
 bool ShelfLayoutManager::IsVisible() const {
-  return shelf_->status_area_widget()->IsVisible() &&
+  // 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));
 }
 
 bool ShelfLayoutManager::SetAlignment(ShelfAlignment alignment) {
   if (alignment_ == alignment)
     return false;
 
   alignment_ = alignment;
@@ skipping 309 matching lines @@
 
 void ShelfLayoutManager::SetState(ShelfVisibilityState visibility_state) {
   if (!shelf_->GetNativeView())
     return;
 
   State state;
   state.visibility_state = visibility_state;
   state.auto_hide_state = CalculateAutoHideState(visibility_state);
   state.is_screen_locked =
       Shell::GetInstance()->session_state_delegate()->IsScreenLocked();
+  state.window_state = workspace_controller_ ?
+      workspace_controller_->GetWindowState() : WORKSPACE_WINDOW_STATE_DEFAULT;
 
   // It's possible for SetState() when a window becomes maximized but the state
   // won't have changed value. Do the dimming check before the early exit.
-  if (workspace_controller_) {
-    shelf_->SetDimsShelf(
-        (state.visibility_state == SHELF_VISIBLE) &&
-          workspace_controller_->GetWindowState() ==
-              WORKSPACE_WINDOW_STATE_MAXIMIZED);
-  }
+  shelf_->SetDimsShelf(
+      (state.visibility_state == SHELF_VISIBLE) &&
+      state.window_state == WORKSPACE_WINDOW_STATE_MAXIMIZED);
 
   if (state_.Equals(state))
     return;  // Nothing changed.
 
   FOR_EACH_OBSERVER(ShelfLayoutManagerObserver, observers_,
                     WillChangeVisibilityState(visibility_state));
 
   if (state.visibility_state == SHELF_AUTO_HIDE) {
     // When state is SHELF_AUTO_HIDE we need to track when the mouse is over the
     // launcher to unhide the shelf. AutoHideEventFilter does that for us.
     if (!auto_hide_event_filter_)
       auto_hide_event_filter_.reset(new AutoHideEventFilter(this));
   } else {
     auto_hide_event_filter_.reset(NULL);
   }
 
   auto_hide_timer_.Stop();
 
-  // Animating the background when transitioning from auto-hide & hidden to
-  // visible is janky. Update the background immediately in this case.
+  // The transition of background from auto-hide to visible is janky if the
+  // transition also cause the shelf's slide animation from the bottom edge.
+  // This happens if:
+  //  - shelf is hidden
+  //  - or, shelf is visible but workspace state is maximized
+  bool keep_maximized = state_.window_state == state.window_state &&
+      state_.window_state == WORKSPACE_WINDOW_STATE_MAXIMIZED;
   BackgroundAnimator::ChangeType change_type =
       (state_.visibility_state == SHELF_AUTO_HIDE &&
-       state_.auto_hide_state == SHELF_AUTO_HIDE_HIDDEN &&
-       state.visibility_state == SHELF_VISIBLE) ?
+       state.visibility_state == SHELF_VISIBLE &&
+       (state_.auto_hide_state == SHELF_AUTO_HIDE_HIDDEN ||
+        keep_maximized)) ?
       BackgroundAnimator::CHANGE_IMMEDIATE : BackgroundAnimator::CHANGE_ANIMATE;
 
   State old_state = state_;
   state_ = state;
   TargetBounds target_bounds;
   CalculateTargetBounds(state_, &target_bounds);
 
   ui::ScopedLayerAnimationSettings launcher_animation_setter(
       GetLayer(shelf_)->GetAnimator());
   launcher_animation_setter.SetTransitionDuration(
@@ skipping 10 matching lines @@
       base::TimeDelta::FromMilliseconds(kWorkspaceSwitchTimeMS));
   status_animation_setter.SetTweenType(ui::Tween::EASE_OUT);
   status_animation_setter.SetPreemptionStrategy(
       ui::LayerAnimator::IMMEDIATELY_ANIMATE_TO_NEW_TARGET);
 
   // Delay updating the background when going from SHELF_AUTO_HIDE_SHOWN to
   // SHELF_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).
+  // But do not delay if the transition happens when a window is maximized.
   bool delay_shelf_update =
       state.visibility_state == SHELF_AUTO_HIDE &&
       state.auto_hide_state == SHELF_AUTO_HIDE_HIDDEN &&
       old_state.visibility_state == SHELF_AUTO_HIDE;
 
-  if (state.visibility_state == SHELF_VISIBLE &&
+  if (!keep_maximized && state.visibility_state == SHELF_VISIBLE &&
       old_state.visibility_state == SHELF_AUTO_HIDE &&
       old_state.auto_hide_state == SHELF_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_);
@@ skipping 204 matching lines @@
     gfx::Rect status_x = target_bounds->shelf_bounds_in_root;
     status_x.set_x(0);
     status_x.ClampToCenteredSize(
         target_bounds->status_bounds_in_shelf.size());
     target_bounds->status_bounds_in_shelf.set_x(status_x.x());
   }
 }
 
 void ShelfLayoutManager::UpdateShelfBackground(
     BackgroundAnimator::ChangeType type) {
-  bool launcher_paints = GetLauncherPaintsBackground();
-  shelf_->SetPaintsBackground(launcher_paints, type);
+  shelf_->SetPaintsBackground(GetShelfBackgroundType(), type);
 }
 
-bool ShelfLayoutManager::GetLauncherPaintsBackground() const {
-  return gesture_drag_status_ == GESTURE_DRAG_IN_PROGRESS ||
+ShelfBackgroundType ShelfLayoutManager::GetShelfBackgroundType() const {
+  if (state_.visibility_state != SHELF_AUTO_HIDE &&
+      state_.window_state == WORKSPACE_WINDOW_STATE_MAXIMIZED) {
+    return SHELF_BACKGROUND_MAXIMIZED;
+  }
+
+  if (gesture_drag_status_ == GESTURE_DRAG_IN_PROGRESS ||
       (!state_.is_screen_locked && window_overlaps_shelf_) ||
-      (state_.visibility_state == SHELF_AUTO_HIDE);
+      (state_.visibility_state == SHELF_AUTO_HIDE)) {
+    return SHELF_BACKGROUND_OVERLAP;
+  }
+
+  return SHELF_BACKGROUND_DEFAULT;
 }
 
 void ShelfLayoutManager::UpdateAutoHideStateNow() {
   SetState(state_.visibility_state);
 }
 
 ShelfAutoHideState ShelfLayoutManager::CalculateAutoHideState(
     ShelfVisibilityState visibility_state) const {
   if (visibility_state != SHELF_AUTO_HIDE || !shelf_)
     return SHELF_AUTO_HIDE_HIDDEN;
@@ skipping 114 matching lines @@
       return gfx::Insets(0, distance, 0, 0);
     case SHELF_ALIGNMENT_TOP:
       return gfx::Insets(0, 0, distance, 0);
   }
   NOTREACHED();
   return gfx::Insets();
 }
 
 }  // namespace internal
 }  // namespace ash