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

ash/shelf/shelf_widget.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_widget.h"
 
 #include "ash/focus_cycler.h"
 #include "ash/launcher/launcher_delegate.h"
 #include "ash/launcher/launcher_model.h"
 #include "ash/launcher/launcher_navigator.h"
 #include "ash/launcher/launcher_view.h"
 #include "ash/root_window_controller.h"
 #include "ash/session_state_delegate.h"
 #include "ash/shelf/shelf_layout_manager.h"
 #include "ash/shelf/shelf_widget.h"
 #include "ash/shell.h"
 #include "ash/shell_window_ids.h"
 #include "ash/wm/property_util.h"
 #include "ash/wm/status_area_layout_manager.h"
 #include "ash/wm/window_properties.h"
 #include "ash/wm/workspace_controller.h"
 #include "grit/ash_resources.h"
 #include "ui/aura/client/activation_client.h"
 #include "ui/aura/root_window.h"
 #include "ui/aura/window.h"
 #include "ui/aura/window_observer.h"
 #include "ui/base/events/event_constants.h"
 #include "ui/base/resource/resource_bundle.h"
 #include "ui/compositor/layer.h"
+#include "ui/compositor/scoped_layer_animation_settings.h"
 #include "ui/gfx/canvas.h"
 #include "ui/gfx/image/image.h"
 #include "ui/gfx/image/image_skia_operations.h"
 #include "ui/gfx/skbitmap_operations.h"
 #include "ui/views/accessible_pane_view.h"
 #include "ui/views/widget/widget.h"
 #include "ui/views/widget/widget_delegate.h"
 
 namespace {
 // Size of black border at bottom (or side) of launcher.
 const int kNumBlackPixels = 3;
 // Alpha to paint dimming image with.
 const int kDimAlpha = 128;
 
 // The time to dim and un-dim.
 const int kTimeToDimMs = 3000;  // Slow in dimming.
 const int kTimeToUnDimMs = 200;  // Fast in activating.
+const int kTimeToSwitchBackgroundMs = 1000;
 
 // Class used to slightly dim shelf items when maximized and visible.
 class DimmerView : public views::View,
                    public views::WidgetDelegate,
                    ash::internal::BackgroundAnimatorDelegate {
  public:
   // If |disable_dimming_animations_for_test| is set, all alpha animations will
   // be performed instantly.
   DimmerView(ash::ShelfWidget* shelf_widget,
              bool disable_dimming_animations_for_test);
@@ skipping 182 matching lines @@
   explicit DelegateView(ShelfWidget* shelf);
   virtual ~DelegateView();
 
   void set_focus_cycler(internal::FocusCycler* focus_cycler) {
     focus_cycler_ = focus_cycler;
   }
   internal::FocusCycler* focus_cycler() {
     return focus_cycler_;
   }
 
+  ui::Layer* opaque_background() { return &opaque_background_; }
+
   // Set if the shelf area is dimmed (eg when a window is maximized).
   void SetDimmed(bool dimmed);
   bool GetDimmed() const;
 
   // Set the bounds of the widget.
   void SetWidgetBounds(const gfx::Rect bounds);
 
+  void SetParentLayer(ui::Layer* layer);
+
   // views::View overrides:
   virtual void OnPaintBackground(gfx::Canvas* canvas) OVERRIDE;
 
   // views::WidgetDelegateView overrides:
   virtual views::Widget* GetWidget() OVERRIDE {
     return View::GetWidget();
   }
   virtual const views::Widget* GetWidget() const OVERRIDE {
     return View::GetWidget();
   }
 
   virtual bool CanActivate() const OVERRIDE;
   virtual void Layout() OVERRIDE;
+  virtual void ReorderChildLayers(ui::Layer* parent_layer) OVERRIDE;
+  virtual void OnBoundsChanged(const gfx::Rect& old_bounds) OVERRIDE;
 
   // BackgroundAnimatorDelegate overrides:
   virtual void UpdateBackground(int alpha) OVERRIDE;
 
   // Force the shelf to be presented in an undimmed state.
   void ForceUndimming(bool force);
 
   // A function to test the current alpha used by the dimming bar. If there is
   // no dimmer active, the function will return -1.
   int GetDimmingAlphaForTest();
 
   // A function to test the bounds of the dimming bar. Returns gfx::Rect() if
   // the dimmer is inactive.
   gfx::Rect GetDimmerBoundsForTest();
 
   // Disable dimming animations for running tests. This needs to be called
   // prior to the creation of of the |dimmer_|.
   void disable_dimming_animations_for_test() {
     disable_dimming_animations_for_test_ = true;
   }
 
  private:
   ShelfWidget* shelf_;
   scoped_ptr<views::Widget> dimmer_;
   internal::FocusCycler* focus_cycler_;
   int alpha_;
+  ui::Layer opaque_background_;
 
   // The view which does the dimming.
   DimmerView* dimmer_view_;
 
   // True if dimming animations should be turned off.
   bool disable_dimming_animations_for_test_;
 
   DISALLOW_COPY_AND_ASSIGN(DelegateView);
 };
 
 ShelfWidget::DelegateView::DelegateView(ShelfWidget* shelf)
     : shelf_(shelf),
       focus_cycler_(NULL),
       alpha_(0),
+      opaque_background_(ui::LAYER_SOLID_COLOR),
       dimmer_view_(NULL),
       disable_dimming_animations_for_test_(false) {
   set_allow_deactivate_on_esc(true);
+  opaque_background_.SetColor(SK_ColorBLACK);
+  opaque_background_.SetBounds(GetLocalBounds());
+  opaque_background_.SetOpacity(0.0f);
 }
 
 ShelfWidget::DelegateView::~DelegateView() {
 }
 
 void ShelfWidget::DelegateView::SetDimmed(bool value) {
   if (value == (dimmer_.get() != NULL))
     return;
 
   if (value) {
@@ skipping 22 matching lines @@
 
 bool ShelfWidget::DelegateView::GetDimmed() const {
   return dimmer_.get() && dimmer_->IsVisible();
 }
 
 void ShelfWidget::DelegateView::SetWidgetBounds(const gfx::Rect bounds) {
   if (dimmer_)
     dimmer_->SetBounds(bounds);
 }
 
+void ShelfWidget::DelegateView::SetParentLayer(ui::Layer* layer) {
+  layer->Add(&opaque_background_);
+  ReorderLayers();
+}
+
 void ShelfWidget::DelegateView::OnPaintBackground(gfx::Canvas* canvas) {
   ResourceBundle& rb = ResourceBundle::GetSharedInstance();
   gfx::ImageSkia launcher_background =
       *rb.GetImageSkiaNamed(IDR_AURA_LAUNCHER_BACKGROUND);
   if (SHELF_ALIGNMENT_BOTTOM != shelf_->GetAlignment())
     launcher_background = gfx::ImageSkiaOperations::CreateRotatedImage(
         launcher_background,
         shelf_->shelf_layout_manager()->SelectValueForShelfAlignment(
             SkBitmapOperations::ROTATION_90_CW,
             SkBitmapOperations::ROTATION_90_CW,
@@ skipping 34 matching lines @@
     if (shelf_->shelf_layout_manager()->IsHorizontalAlignment()) {
       child_at(i)->SetBounds(child_at(i)->x(), child_at(i)->y(),
                              child_at(i)->width(), height());
     } else {
       child_at(i)->SetBounds(child_at(i)->x(), child_at(i)->y(),
                              width(), child_at(i)->height());
     }
   }
 }
 
+void ShelfWidget::DelegateView::ReorderChildLayers(ui::Layer* parent_layer) {
+  views::View::ReorderChildLayers(parent_layer);
+  parent_layer->StackAtBottom(&opaque_background_);
+}
+
+void ShelfWidget::DelegateView::OnBoundsChanged(const gfx::Rect& old_bounds) {
+  opaque_background_.SetBounds(GetLocalBounds());
+}
+
 void ShelfWidget::DelegateView::ForceUndimming(bool force) {
   if (GetDimmed())
     dimmer_view_->ForceUndimming(force);
 }
 
 int ShelfWidget::DelegateView::GetDimmingAlphaForTest() {
   if (GetDimmed())
     return dimmer_view_->get_dimming_alpha_for_test();
   return -1;
 }
@@ skipping 20 matching lines @@
       views::Widget::InitParams::TYPE_WINDOW_FRAMELESS);
   params.opacity = views::Widget::InitParams::TRANSLUCENT_WINDOW;
   params.ownership = views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET;
   params.parent = shelf_container;
   params.delegate = delegate_view_;
   Init(params);
 
   // The shelf should not take focus when initially shown.
   set_focus_on_creation(false);
   SetContentsView(delegate_view_);
+  delegate_view_->SetParentLayer(GetLayer());
 
   status_area_widget_ = new internal::StatusAreaWidget(status_container);
   status_area_widget_->CreateTrayViews();
   if (Shell::GetInstance()->session_state_delegate()->
           IsActiveUserSessionStarted()) {
     status_area_widget_->Show();
   }
   Shell::GetInstance()->focus_cycler()->AddWidget(status_area_widget_);
 
   shelf_layout_manager_ = new internal::ShelfLayoutManager(this);
   shelf_container->SetLayoutManager(shelf_layout_manager_);
   shelf_layout_manager_->set_workspace_controller(workspace_controller);
   workspace_controller->SetShelf(shelf_layout_manager_);
 
   status_container->SetLayoutManager(
       new internal::StatusAreaLayoutManager(this));
 
   views::Widget::AddObserver(this);
   GetNativeView()->SetProperty(internal::kStayInSameRootWindowKey, true);
 }
 
 ShelfWidget::~ShelfWidget() {
   RemoveObserver(this);
 }
 
 void ShelfWidget::SetPaintsBackground(
-    bool value,
+    ShelfBackgroundType background_type,
     internal::BackgroundAnimator::ChangeType change_type) {
-  background_animator_.SetPaintsBackground(value, change_type);
+  ui::Layer* opaque_background = delegate_view_->opaque_background();
+  float target_opacity =
+      (background_type == SHELF_BACKGROUND_MAXIMIZED) ? 1.0f : 0.0f;
+  scoped_ptr<ui::ScopedLayerAnimationSettings> opaque_background_animation;
+  if (change_type != internal::BackgroundAnimator::CHANGE_IMMEDIATE) {
+    opaque_background_animation.reset(new ui::ScopedLayerAnimationSettings(
+        opaque_background->GetAnimator()));
+    opaque_background_animation->SetTransitionDuration(
+        base::TimeDelta::FromMilliseconds(kTimeToSwitchBackgroundMs));
+  }
+  opaque_background->SetOpacity(target_opacity);
+
+  // TODO(mukai): use ui::Layer on both opaque_background and normal background
+  // retire background_animator_ at all. It would be simpler.
+  background_animator_.SetPaintsBackground(
+      background_type != SHELF_BACKGROUND_DEFAULT,
+      change_type);
+}
+
+ShelfBackgroundType ShelfWidget::GetBackgroundType() const {
+  if (delegate_view_->opaque_background()->GetTargetOpacity() == 1.0f)
+    return SHELF_BACKGROUND_MAXIMIZED;
+  if (background_animator_.paints_background())
+    return SHELF_BACKGROUND_OVERLAP;
+
+  return SHELF_BACKGROUND_DEFAULT;
 }
 
 ShelfAlignment ShelfWidget::GetAlignment() const {
   return shelf_layout_manager_->GetAlignment();
 }
 
 void ShelfWidget::SetAlignment(ShelfAlignment alignment) {
   if (launcher_)
     launcher_->SetAlignment(alignment);
   status_area_widget_->SetShelfAlignment(alignment);
@@ skipping 90 matching lines @@
     return delegate_view_->GetDimmerBoundsForTest();
   return gfx::Rect();
 }
 
 void ShelfWidget::DisableDimmingAnimationsForTest() {
   DCHECK(delegate_view_);
   return delegate_view_->disable_dimming_animations_for_test();
 }
 
 }  // namespace ash