Remove ExtractImageRep from the browser frame header painting code.

chrome/browser/ui/views/frame/browser_header_painter_ash.cc

 // Copyright 2014 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 "chrome/browser/ui/views/frame/browser_header_painter_ash.h"
 
 #include "ash/common/ash_layout_constants.h"
 #include "ash/common/frame/caption_buttons/frame_caption_button_container_view.h"
 #include "ash/common/frame/header_painter_util.h"
 #include "ash/resources/vector_icons/vector_icons.h"
-#include "base/logging.h"  // DCHECK
+#include "base/logging.h"
 #include "chrome/browser/themes/theme_properties.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/views/frame/browser_frame.h"
 #include "chrome/browser/ui/views/frame/browser_non_client_frame_view_ash.h"
 #include "chrome/browser/ui/views/frame/browser_view.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 "ui/gfx/animation/slide_animation.h"
 #include "ui/gfx/canvas.h"
 #include "ui/gfx/geometry/rect.h"
 #include "ui/gfx/image/image_skia.h"
+#include "ui/gfx/scoped_canvas.h"
 #include "ui/gfx/skia_util.h"
 #include "ui/views/view.h"
 #include "ui/views/widget/widget.h"
 #include "ui/views/widget/widget_delegate.h"
 
 using views::Widget;
 
 namespace {
 
 // Color for the window title text.
@@ skipping 18 matching lines @@
   SkPath path;
   path.addRoundRect(rect, radii, SkPath::kCW_Direction);
   return path;
 }
 
 // Tiles |frame_image| and |frame_overlay_image| into an area, rounding the top
 // corners.
 void PaintFrameImagesInRoundRect(gfx::Canvas* canvas,
                                  const gfx::ImageSkia& frame_image,
                                  const gfx::ImageSkia& frame_overlay_image,
-                                 const cc::PaintFlags& flags,
+                                 int alpha,
+                                 SkColor background_color,
                                  const gfx::Rect& bounds,
                                  int corner_radius,
                                  int image_inset_x) {
   SkPath frame_path = MakeRoundRectPath(bounds, corner_radius, corner_radius);
-  // If |flags| is using an unusual SkBlendMode (this is the case while
-  // crossfading), we must create a new canvas to overlay |frame_image| and
-  // |frame_overlay_image| using |kSrcOver| and then paint the result
-  // using the unusual mode. We try to avoid this because creating a new
-  // browser-width canvas is expensive.
-  bool fast_path = (frame_overlay_image.isNull() || flags.isSrcOver());
-  if (fast_path) {
+  bool antialias = corner_radius > 0;
+
+  gfx::ScopedCanvas scoped_save(canvas);
+  canvas->ClipPath(frame_path, antialias);
+
+  cc::PaintFlags flags;
+  flags.setBlendMode(SkBlendMode::kPlus);
+  flags.setAntiAlias(antialias);
+
+  if (frame_image.isNull() && frame_overlay_image.isNull()) {
+    flags.setColor(background_color);
+    canvas->DrawRect(bounds, flags);
+  } else if (frame_overlay_image.isNull()) {
+    flags.setAlpha(alpha);
+    canvas->DrawImageInt(frame_image, -image_inset_x, 0, flags);
+  } else {
+    flags.setAlpha(alpha);
+    canvas->SaveLayerWithFlags(flags);
+
     if (frame_image.isNull()) {
-      canvas->DrawPath(frame_path, flags);
+      canvas->DrawColor(background_color);
     } else {
-      canvas->DrawImageInPath(frame_image, -image_inset_x, 0, frame_path,
-                              flags);
+      canvas->TileImageInt(frame_image, image_inset_x, 0, 0, 0, bounds.width(),
+                           bounds.height());
     }
+    canvas->DrawImageInt(frame_overlay_image, 0, 0);
 
-    if (!frame_overlay_image.isNull()) {
-      // Adjust |bounds| such that |frame_overlay_image| is not tiled.
-      gfx::Rect overlay_bounds = bounds;
-      overlay_bounds.Intersect(
-          gfx::Rect(bounds.origin(), frame_overlay_image.size()));
-      int top_left_corner_radius = corner_radius;
-      int top_right_corner_radius = corner_radius;
-      if (overlay_bounds.width() < bounds.width() - corner_radius)
-        top_right_corner_radius = 0;
-      canvas->DrawImageInPath(
-          frame_overlay_image, 0, 0,
-          MakeRoundRectPath(overlay_bounds, top_left_corner_radius,
-                            top_right_corner_radius),
-          flags);
-    }
-  } else {
-    gfx::Canvas temporary_canvas(bounds.size(), canvas->image_scale(), false);
-    if (frame_image.isNull()) {
-      temporary_canvas.DrawColor(flags.getColor());
-    } else {
-      temporary_canvas.TileImageInt(frame_image, image_inset_x, 0, 0, 0,
-                                    bounds.width(), bounds.height());
-    }
-    temporary_canvas.DrawImageInt(frame_overlay_image, 0, 0);
-    canvas->DrawImageInPath(gfx::ImageSkia(temporary_canvas.ExtractImageRep()),
-                            0, 0, frame_path, flags);
+    canvas->Restore();
   }
 }
 
 }  // namespace
 
 ///////////////////////////////////////////////////////////////////////////////
 // BrowserHeaderPainterAsh, public:
 
 BrowserHeaderPainterAsh::BrowserHeaderPainterAsh()
     : frame_(nullptr),
@@ skipping 131 matching lines @@
 
 void BrowserHeaderPainterAsh::PaintFrameImages(gfx::Canvas* canvas,
                                                bool active) {
   int alpha = activation_animation_->CurrentValueBetween(0, 0xFF);
   if (!active)
     alpha = 0xFF - alpha;
 
   if (alpha == 0)
     return;
 
-  bool round_corners = !frame_->IsMaximized() && !frame_->IsFullscreen();
   gfx::ImageSkia frame_image = view_->GetFrameImage(active);
   gfx::ImageSkia frame_overlay_image = view_->GetFrameOverlayImage(active);
+  SkColor background_color = SkColorSetA(view_->GetFrameColor(active), alpha);
 
-  cc::PaintFlags flags;
-  flags.setBlendMode(SkBlendMode::kPlus);
-  flags.setAlpha(alpha);
-  flags.setColor(SkColorSetA(view_->GetFrameColor(active), alpha));
-  flags.setAntiAlias(round_corners);
+  int corner_radius = 0;
+  if (!frame_->IsMaximized() && !frame_->IsFullscreen())
+    corner_radius = ash::HeaderPainterUtil::GetTopCornerRadiusWhenRestored();
+
   PaintFrameImagesInRoundRect(
-      canvas, frame_image, frame_overlay_image, flags, GetPaintedBounds(),
-      round_corners ? ash::HeaderPainterUtil::GetTopCornerRadiusWhenRestored()
-                    : 0,
+      canvas, frame_image, frame_overlay_image, alpha, background_color,
+      GetPaintedBounds(), corner_radius,
       ash::HeaderPainterUtil::GetThemeBackgroundXInset());
 }
 
 void BrowserHeaderPainterAsh::PaintTitleBar(gfx::Canvas* canvas) {
   // The window icon is painted by its own views::View.
   gfx::Rect title_bounds = GetTitleBounds();
   title_bounds.set_x(view_->GetMirroredXForRect(title_bounds));
   canvas->DrawStringRectWithFlags(frame_->widget_delegate()->GetWindowTitle(),
                                   BrowserFrame::GetTitleFontList(),
                                   is_incognito_ ? kIncognitoWindowTitleTextColor
@@ skipping 28 matching lines @@
 }
 
 gfx::Rect BrowserHeaderPainterAsh::GetPaintedBounds() const {
   return gfx::Rect(view_->width(), painted_height_);
 }
 
 gfx::Rect BrowserHeaderPainterAsh::GetTitleBounds() const {
   return ash::HeaderPainterUtil::GetTitleBounds(window_icon_,
       caption_button_container_, BrowserFrame::GetTitleFontList());
 }