Revert 129220 - M20 Ash: Animate window header transition from active to inactive

ash/wm/frame_painter.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/wm/frame_painter.h"
 
 #include "ash/wm/window_util.h"
 #include "base/logging.h"  // DCHECK
 #include "grit/ui_resources.h"
 #include "third_party/skia/include/core/SkCanvas.h"
 #include "third_party/skia/include/core/SkColor.h"
 #include "third_party/skia/include/core/SkPaint.h"
 #include "third_party/skia/include/core/SkPath.h"
 #include "third_party/skia/include/core/SkShader.h"
 #include "ui/aura/client/aura_constants.h"
 #include "ui/aura/window.h"
-#include "ui/base/animation/slide_animation.h"
 #include "ui/base/hit_test.h"
 #include "ui/base/resource/resource_bundle.h"
 #include "ui/base/theme_provider.h"
 #include "ui/gfx/canvas.h"
 #include "ui/gfx/font.h"
 #include "ui/gfx/image/image.h"
 #include "ui/views/controls/button/image_button.h"
 #include "ui/views/widget/widget.h"
 #include "ui/views/widget/widget_delegate.h"
 
@@ skipping 34 matching lines @@
 const int kCloseButtonOffsetX = 0;
 // Space between close button and top edge of window.
 const int kCloseButtonOffsetY = 0;
 // In the pre-Ash era the web content area had a frame along the left edge, so
 // user-generated theme images for the new tab page assume they are shifted
 // right relative to the header.  Now that we have removed the left edge frame
 // we need to copy the theme image for the window header from a few pixels
 // inset to preserve alignment with the NTP image, or else we'll break a bunch
 // of existing themes.  We do something similar on OS X for the same reason.
 const int kThemeFrameBitmapOffsetX = 5;
-// Duration of crossfade animation for activating and deactivating frame.
-const int kActivationCrossfadeDurationMs = 200;
 
 // Tiles an image into an area, rounding the top corners.  Samples the |bitmap|
 // starting |bitmap_offset_x| pixels from the left of the image.
 void TileRoundRect(gfx::Canvas* canvas,
                    int x, int y, int w, int h,
-                   SkPaint* paint,
                    const SkBitmap& bitmap,
                    int corner_radius,
                    int bitmap_offset_x) {
   // To get the shader to sample the image |inset_y| pixels in but tile across
   // the whole image, we adjust the target rectangle for the shader to the right
   // and translate the canvas left to compensate.
   SkRect rect;
   rect.iset(x + bitmap_offset_x, y, x + bitmap_offset_x + w, y + h);
   const SkScalar kRadius = SkIntToScalar(corner_radius);
   SkScalar radii[8] = {
       kRadius, kRadius,  // top-left
       kRadius, kRadius,  // top-right
       0, 0,   // bottom-right
       0, 0};  // bottom-left
   SkPath path;
   path.addRoundRect(rect, radii, SkPath::kCW_Direction);
 
+  SkPaint paint;
   SkShader* shader = SkShader::CreateBitmapShader(bitmap,
                                                   SkShader::kRepeat_TileMode,
                                                   SkShader::kRepeat_TileMode);
-  paint->setShader(shader);
+  paint.setShader(shader);
+  paint.setXfermodeMode(SkXfermode::kSrcOver_Mode);
   // CreateBitmapShader returns a Shader with a reference count of one, we
   // need to unref after paint takes ownership of the shader.
   shader->unref();
   // Adjust canvas to compensate for image sampling offset, draw, then adjust
   // back. This is cheaper than pushing/popping the entire canvas state.
   canvas->sk_canvas()->translate(SkIntToScalar(-bitmap_offset_x), 0);
-  canvas->sk_canvas()->drawPath(path, *paint);
+  canvas->sk_canvas()->drawPath(path, paint);
   canvas->sk_canvas()->translate(SkIntToScalar(bitmap_offset_x), 0);
 }
 
 }  // namespace
 
 namespace ash {
 
 ///////////////////////////////////////////////////////////////////////////////
 // FramePainter, public:
 
 FramePainter::FramePainter()
     : frame_(NULL),
       window_icon_(NULL),
       maximize_button_(NULL),
       close_button_(NULL),
       window_(NULL),
       button_separator_(NULL),
       top_left_corner_(NULL),
       top_edge_(NULL),
       top_right_corner_(NULL),
       header_left_edge_(NULL),
-      header_right_edge_(NULL),
-      previous_theme_frame_(NULL),
-      crossfade_theme_frame_(NULL),
-      crossfade_animation_(NULL) {
+      header_right_edge_(NULL) {
 }
 
 FramePainter::~FramePainter() {
   if (window_)
     window_->RemoveObserver(this);
 
 }
 
 void FramePainter::Init(views::Widget* frame,
                         views::View* window_icon,
@@ skipping 116 matching lines @@
   if (title_width > min_size.width())
     min_size.set_width(title_width);
   return min_size;
 }
 
 void FramePainter::PaintHeader(views::NonClientFrameView* view,
                                gfx::Canvas* canvas,
                                const SkBitmap* theme_frame,
                                const SkBitmap* theme_frame_overlay) {
 
-  if (previous_theme_frame_ && previous_theme_frame_ != theme_frame) {
-    crossfade_animation_.reset(new ui::SlideAnimation(this));
-    crossfade_theme_frame_ = previous_theme_frame_;
-    crossfade_animation_->SetSlideDuration(kActivationCrossfadeDurationMs);
-    crossfade_animation_->Show();
-  }
-
-  header_frame_bounds_ = gfx::Rect(0, 0, view->width(), theme_frame->height());
+  // Draw the header background, clipping the corners to be rounded.
   const int kCornerRadius = 2;
-
-  SkPaint paint;
-  if (crossfade_animation_.get() && crossfade_animation_->is_animating()) {
-    uint8 theme_alpha = crossfade_animation_->GetCurrentValue() * 255;
-
-    // Draw the old header background, clipping the corners to be rounded.
-    paint.setAlpha(255 - theme_alpha);
-    paint.setXfermodeMode(SkXfermode::kPlus_Mode);
-    TileRoundRect(canvas,
-                  0, 0, view->width(), theme_frame->height(),
-                  &paint,
-                  *crossfade_theme_frame_,
-                  kCornerRadius,
-                  kThemeFrameBitmapOffsetX);
-
-    paint.setAlpha(theme_alpha);
-  }
-
-  // Draw the header background, clipping the corners to be rounded.
   TileRoundRect(canvas,
                 0, 0, view->width(), theme_frame->height(),
-                &paint,
                 *theme_frame,
                 kCornerRadius,
                 kThemeFrameBitmapOffsetX);
 
-  previous_theme_frame_ = theme_frame;
-
   // Draw the theme frame overlay, if available.
   if (theme_frame_overlay)
     canvas->DrawBitmapInt(*theme_frame_overlay, 0, 0);
 
   // Separator between the maximize and close buttons.
   canvas->DrawBitmapInt(*button_separator_,
                         close_button_->x() - button_separator_->width(),
                         close_button_->y());
 
   // We don't need the extra lightness in the edges when we're maximized.
@@ skipping 141 matching lines @@
 
 void FramePainter::OnWindowDestroying(aura::Window* window) {
   DCHECK_EQ(window_, window);
   // Must be removed here and not in the destructor, as the aura::Window is
   // already destroyed when our destructor runs.
   window_->RemoveObserver(this);
   window_ = NULL;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
-// ui::AnimationDelegate overrides:
-
-void FramePainter::AnimationProgressed(const ui::Animation* animation) {
-  frame_->SchedulePaintInRect(gfx::Rect(header_frame_bounds_));
-}
-
-///////////////////////////////////////////////////////////////////////////////
 // FramePainter, private:
 
 void FramePainter::SetButtonImages(views::ImageButton* button,
                                    int normal_bitmap_id,
                                    int hot_bitmap_id,
                                    int pushed_bitmap_id) {
   ui::ThemeProvider* theme_provider = frame_->GetThemeProvider();
   button->SetImage(views::CustomButton::BS_NORMAL,
                    theme_provider->GetBitmapNamed(normal_bitmap_id));
   button->SetImage(views::CustomButton::BS_HOT,
                    theme_provider->GetBitmapNamed(hot_bitmap_id));
   button->SetImage(views::CustomButton::BS_PUSHED,
                    theme_provider->GetBitmapNamed(pushed_bitmap_id));
 }
 
 int FramePainter::GetTitleOffsetX() const {
   return window_icon_ ?
       window_icon_->bounds().right() + kTitleIconOffsetX :
       kTitleNoIconOffsetX;
 }
 
 }  // namespace ash