Fixes missing 5 pixel inset for theme background in Ash

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/ash_constants.h"
 #include "ash/shell.h"
 #include "ash/shell_window_ids.h"
 #include "ash/wm/window_util.h"
@@ skipping 58 matching lines @@
 const int kCloseButtonOffsetY = 0;
 // The size and close buttons are designed to slightly overlap in order
 // to do fancy hover highlighting.
 const int kButtonOverlap = 1;
 // 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 kThemeFrameImageOffsetX = 5;
+const int kThemeFrameImageInsetX = 5;
 // Duration of crossfade animation for activating and deactivating frame.
 const int kActivationCrossfadeDurationMs = 200;
 // Alpha/opacity value for fully-opaque headers.
 const int kFullyOpaque = 255;
 
 // 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,
                    const SkPaint& paint,
                    const gfx::ImageSkia& image,
                    int corner_radius,
-                   int image_offset_x) {
+                   int image_inset_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, y, 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);
-  canvas->DrawImageInPath(image, -image_offset_x, 0, path, paint);
+  canvas->DrawImageInPath(image, -image_inset_x, 0, path, paint);
 }
 
 // Returns true if |window| is a visible, normal window.
 bool IsVisibleNormalWindow(aura::Window* window) {
   // We must use TargetVisibility() because windows animate in and out and
   // IsVisible() also tracks the layer visibility state.
   return window &&
     window->TargetVisibility() &&
     (window->type() == aura::client::WINDOW_TYPE_NORMAL ||
      window->type() == aura::client::WINDOW_TYPE_PANEL);
@@ skipping 177 matching lines @@
   return min_size;
 }
 
 int FramePainter::GetRightInset() const {
   gfx::Size close_size = close_button_->GetPreferredSize();
   gfx::Size size_button_size = size_button_->GetPreferredSize();
   return close_size.width() + kCloseButtonOffsetX + size_button_size.width() -
       kButtonOverlap;
 }
 
+int FramePainter::GetThemeBackgroundXInset() const {
+  return kThemeFrameImageInsetX;
+}
+
 void FramePainter::PaintHeader(views::NonClientFrameView* view,
                                gfx::Canvas* canvas,
                                HeaderMode header_mode,
                                int theme_frame_id,
                                const gfx::ImageSkia* theme_frame_overlay) {
   if (previous_theme_frame_id_ != 0 &&
       previous_theme_frame_id_ != theme_frame_id) {
     crossfade_animation_.reset(new ui::SlideAnimation(this));
     crossfade_theme_frame_id_ = previous_theme_frame_id_;
     crossfade_opacity_ = previous_opacity_;
@@ skipping 20 matching lines @@
       int new_alpha = current_value * opacity;
 
       // Draw the old header background, clipping the corners to be rounded.
       paint.setAlpha(old_alpha);
       paint.setXfermodeMode(SkXfermode::kPlus_Mode);
       TileRoundRect(canvas,
                     0, 0, view->width(), theme_frame->height(),
                     paint,
                     *crossfade_theme_frame,
                     kCornerRadius,
-                    kThemeFrameImageOffsetX);
+                    GetThemeBackgroundXInset());
 
       paint.setAlpha(new_alpha);
     } else {
       crossfade_animation_.reset();
       paint.setAlpha(opacity);
     }
   } else {
     paint.setAlpha(opacity);
   }
 
   // Draw the header background, clipping the corners to be rounded.
   TileRoundRect(canvas,
                 0, 0, view->width(), theme_frame->height(),
                 paint,
                 *theme_frame,
                 kCornerRadius,
-                kThemeFrameImageOffsetX);
+                GetThemeBackgroundXInset());
 
   previous_theme_frame_id_ = theme_frame_id;
   previous_opacity_ = opacity;
 
   // Draw the theme frame overlay, if available.
   if (theme_frame_overlay)
     canvas->DrawImageInt(*theme_frame_overlay, 0, 0);
 
   // Separator between the maximize and close buttons.  It overlaps the left
   // edge of the close button.
@@ skipping 249 matching lines @@
   for (std::set<FramePainter*>::const_iterator it = instances_->begin();
        it != instances_->end();
        ++it) {
     FramePainter* painter = *it;
     if (IsVisibleNormalWindow(painter->window_))
       painter->frame_->non_client_view()->SchedulePaint();
   }
 }
 
 }  // namespace ash