Animating docked background in sync with shelf

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/ash_switches.h"
 #include "ash/focus_cycler.h"
 #include "ash/launcher/launcher_delegate.h"
 #include "ash/root_window_controller.h"
@@ skipping 28 matching lines @@
 
 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 77 matching lines @@
                        bool disable_dimming_animations_for_test)
     : shelf_(shelf_widget),
       alpha_(kDimAlpha),
       is_hovered_(false),
       force_hovered_(false),
       disable_dimming_animations_for_test_(disable_dimming_animations_for_test),
       background_animator_(this, 0, kDimAlpha) {
   event_filter_.reset(new DimmerEventFilter(this));
   // Make sure it is undimmed at the beginning and then fire off the dimming
   // animation.
-  background_animator_.SetPaintsBackground(false,
-      ash::internal::BackgroundAnimator::CHANGE_IMMEDIATE);
+  background_animator_.SetPaintsBackground(false, ash::CHANGE_IMMEDIATE);
   SetHovered(false);
 }
 
 DimmerView::~DimmerView() {
 }
 
 void DimmerView::SetHovered(bool hovered) {
   // Remember the hovered state so that we can correct the state once a
   // possible force state has disappeared.
   is_hovered_ = hovered;
   // Undimm also if we were forced to by e.g. an open menu.
   hovered |= force_hovered_;
   background_animator_.SetDuration(hovered ? kTimeToUnDimMs : kTimeToDimMs);
   background_animator_.SetPaintsBackground(!hovered,
       disable_dimming_animations_for_test_ ?
-          ash::internal::BackgroundAnimator::CHANGE_IMMEDIATE :
-          ash::internal::BackgroundAnimator::CHANGE_ANIMATE);
+          ash::CHANGE_IMMEDIATE : ash::CHANGE_ANIMATE);
 }
 
 void DimmerView::ForceUndimming(bool force) {
   bool previous = force_hovered_;
   force_hovered_ = force;
   // If the forced change does change the result we apply the change.
   if (is_hovered_ || force_hovered_ != is_hovered_ || previous)
     SetHovered(is_hovered_);
 }
 
@@ skipping 208 matching lines @@
   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,
             SkBitmapOperations::ROTATION_270_CW,
             SkBitmapOperations::ROTATION_180_CW));
-
+  const gfx::Rect dock_bounds(shelf_->shelf_layout_manager()->dock_bounds());
+  SkPaint paint;
+  paint.setAlpha(alpha_);
+  canvas->DrawImageInt(
+      launcher_background,
+      0, 0, launcher_background.width(), launcher_background.height(),
+      (SHELF_ALIGNMENT_BOTTOM == shelf_->GetAlignment() &&
+       dock_bounds.x() == 0 && dock_bounds.width() > 0) ?
+           dock_bounds.width() : 0, 0,
+      SHELF_ALIGNMENT_BOTTOM == shelf_->GetAlignment() ?
+          width() - dock_bounds.width() : width(), height(),
+      false,
+      paint);
+  if (SHELF_ALIGNMENT_BOTTOM == shelf_->GetAlignment() &&
+      dock_bounds.width() > 0) {
+    // The part of the shelf background that is in the corner below the docked
+    // windows close to the work area is an arched gradient that blends
+    // vertically oriented docked background and horizontal shelf.
+    gfx::ImageSkia launcher_corner =
+        *rb.GetImageSkiaNamed(IDR_AURA_LAUNCHER_CORNER);
+    if (dock_bounds.x() == 0) {
+      launcher_corner = gfx::ImageSkiaOperations::CreateRotatedImage(
+          launcher_corner, SkBitmapOperations::ROTATION_90_CW);
+    }
+    canvas->DrawImageInt(
+        launcher_corner,
+        0, 0, launcher_corner.width(), launcher_corner.height(),
+        dock_bounds.x() > 0 ? dock_bounds.x() : dock_bounds.width() - height(),
+        0,
+        height(), height(),
+        false,
+        paint);
+    // The part of the shelf background that is just below the docked windows
+    // is drawn using the last (lowest) 1-pixel tall strip of the image asset.
+    // This avoids showing the border 3D shadow between the shelf and the dock.
+    canvas->DrawImageInt(
+        launcher_background,
+        0, launcher_background.height() - 1, launcher_background.width(), 1,
+        dock_bounds.x() > 0 ? dock_bounds.x() + height() : 0, 0,
+        dock_bounds.width() - height(), height(),
+        false,
+        paint);
+  }
   gfx::Rect black_rect =
       shelf_->shelf_layout_manager()->SelectValueForShelfAlignment(
           gfx::Rect(0, height() - kNumBlackPixels, width(), kNumBlackPixels),
           gfx::Rect(0, 0, kNumBlackPixels, height()),
           gfx::Rect(width() - kNumBlackPixels, 0, kNumBlackPixels, height()),
           gfx::Rect(0, 0, width(), kNumBlackPixels));
-
-  SkPaint paint;
-  paint.setAlpha(alpha_);
-  canvas->DrawImageInt(
-      launcher_background,
-      0, 0, launcher_background.width(), launcher_background.height(),
-      0, 0, width(), height(),
-      false,
-      paint);
   canvas->FillRect(black_rect, SK_ColorBLACK);
 }
 
 bool ShelfWidget::DelegateView::CanActivate() const {
   // Allow to activate as fallback.
   if (shelf_->activating_as_fallback_)
     return true;
   // Allow to activate from the focus cycler.
   if (focus_cycler_ && focus_cycler_->widget_activating() == GetWidget())
     return true;
@@ skipping 94 matching lines @@
 
   views::Widget::AddObserver(this);
 }
 
 ShelfWidget::~ShelfWidget() {
   RemoveObserver(this);
 }
 
 void ShelfWidget::SetPaintsBackground(
     ShelfBackgroundType background_type,
-    internal::BackgroundAnimator::ChangeType change_type) {
+    BackgroundAnimatorChangeType 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) {
+  if (change_type != 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.
+  // See also DockedBackgroundWidget::SetPaintsBackground.
   background_animator_.SetPaintsBackground(
       background_type != SHELF_BACKGROUND_DEFAULT,
       change_type);
+  delegate_view_->SchedulePaint();
 }
 
 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;
 }
@@ skipping 121 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