Fix the misalignment on CrOS of the tab background images

chrome/browser/ui/views/tabs/tab.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 "chrome/browser/ui/views/tabs/tab.h"
 
 #include <limits>
 
 #include "base/command_line.h"
 #include "base/debug/alias.h"
 #include "base/strings/utf_string_conversions.h"
 #include "chrome/browser/defaults.h"
 #include "chrome/browser/themes/theme_properties.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/tab_contents/core_tab_helper.h"
 #include "chrome/browser/ui/tabs/tab_resources.h"
 #include "chrome/browser/ui/view_ids.h"
 #include "chrome/browser/ui/views/tabs/tab_controller.h"
+#include "chrome/browser/ui/views/tabs/tab_util.h"
 #include "chrome/browser/ui/views/theme_image_mapper.h"
 #include "chrome/browser/ui/views/touch_uma/touch_uma.h"
 #include "chrome/common/chrome_switches.h"
 #include "grit/generated_resources.h"
 #include "grit/theme_resources.h"
 #include "grit/ui_resources.h"
 #include "third_party/skia/include/effects/SkGradientShader.h"
 #include "ui/base/accessibility/accessible_view_state.h"
 #include "ui/base/animation/animation_container.h"
 #include "ui/base/animation/multi_animation.h"
@@ skipping 1196 matching lines @@
   // And then the gradient on top of that.
   if (animation->current_part_index() == 2) {
     uint8 alpha = animation->CurrentValueBetween(255, 0);
     canvas->DrawImageInt(hover_image, 0, 0, alpha);
   } else {
     canvas->DrawImageInt(hover_image, 0, 0);
   }
 }
 
 void Tab::PaintInactiveTabBackground(gfx::Canvas* canvas) {
-  int tab_id;
-  int frame_id;
+  int background_id;
+  int background_overlay_id;
   views::Widget* widget = GetWidget();
-  GetTabIdAndFrameId(widget, &tab_id, &frame_id);
+  GetInactiveBackgroundIdAndOverlayId(widget, &background_id,
+      &background_overlay_id);
 
   // Explicitly map the id so we cache correctly.
   const chrome::HostDesktopType host_desktop_type = GetHostDesktopType(this);
-  tab_id = chrome::MapThemeImage(host_desktop_type, tab_id);
+  background_id = chrome::MapThemeImage(host_desktop_type, background_id);
 
   // HasCustomImage() is only true if the theme provides the image. However,
   // even if the theme does not provide a tab background, the theme machinery
   // will make one if given a frame image.
   ui::ThemeProvider* theme_provider = GetThemeProvider();
-  const bool theme_provided_image = theme_provider->HasCustomImage(tab_id) ||
-      (frame_id != 0 && theme_provider->HasCustomImage(frame_id));
+  const bool theme_provided_image =
+      theme_provider->HasCustomImage(IDR_THEME_FRAME) ||
+      theme_provider->HasCustomImage(background_id) ||
+      theme_provider->HasCustomImage(background_overlay_id);
 
   const bool can_cache = !theme_provided_image &&
       !hover_controller_.ShouldDraw();
 
   if (can_cache) {
+     // The default theme does not provide background overlay images.
     gfx::ImageSkia cached_image(
-        GetCachedImage(tab_id, size(), canvas->scale_factor()));
+        GetCachedImage(background_id, size(), canvas->scale_factor()));
     if (cached_image.width() == 0) {
       gfx::Canvas tmp_canvas(size(), canvas->scale_factor(), false);
-      PaintInactiveTabBackgroundUsingResourceId(&tmp_canvas, tab_id);
+      PaintInactiveTabBackgroundUsingResourceIds(&tmp_canvas, background_id,
+          background_overlay_id);
       cached_image = gfx::ImageSkia(tmp_canvas.ExtractImageRep());
-      SetCachedImage(tab_id, canvas->scale_factor(), cached_image);
+      SetCachedImage(background_id, canvas->scale_factor(), cached_image);
     }
     canvas->DrawImageInt(cached_image, 0, 0);
   } else {
-    PaintInactiveTabBackgroundUsingResourceId(canvas, tab_id);
+    PaintInactiveTabBackgroundUsingResourceIds(canvas, background_id,
+        background_overlay_id);
   }
 }
 
-void Tab::PaintInactiveTabBackgroundUsingResourceId(gfx::Canvas* canvas,
-                                                    int tab_id) {
+void Tab::PaintInactiveTabBackgroundUsingResourceIds(
+    gfx::Canvas* canvas,
+    int background_id,
+    int background_overlay_id) {
   // WARNING: the inactive tab background may be cached. If you change what it
   // is drawn from you may need to update whether it can be cached.
 
   // The tab image needs to be lined up with the background image
-  // so that it feels partially transparent.  These offsets represent the tab
+  // so that it feels partially transparent. This offset represents the tab
   // position within the frame background image.
   int offset = GetMirroredX() + background_offset_.x();
 
-  gfx::ImageSkia* tab_bg = GetThemeProvider()->GetImageSkiaNamed(tab_id);
-
+  ui::ThemeProvider* tp = GetThemeProvider();
   TabImage* tab_image = &tab_active_;
   TabImage* tab_inactive_image = &tab_inactive_;
   TabImage* alpha = &tab_alpha_;
 
-  // If the theme is providing a custom background image, then its top edge
-  // should be at the top of the tab. Otherwise, we assume that the background
-  // image is a composited foreground + frame image.
-  int bg_offset_y = GetThemeProvider()->HasCustomImage(tab_id) ?
-      0 : background_offset_.y();
-
   // We need a gfx::Canvas object to be able to extract the image from.
   // We draw everything to this canvas and then output it to the canvas
   // parameter in addition to using it to mask the hover glow if needed.
   gfx::Canvas background_canvas(size(), canvas->scale_factor(), false);
 
   // Draw left edge.  Don't draw over the toolbar, as we're not the foreground
   // tab.
-  gfx::ImageSkia tab_l = gfx::ImageSkiaOperations::CreateTiledImage(
-      *tab_bg, offset, bg_offset_y, tab_image->l_width, height());
+  gfx::ImageSkia tab_l = TabUtil::CreateTiledInactiveBackground(tp,
+      background_id, background_overlay_id, background_offset_.y(), offset, 0,
+      tab_image->l_width, height());
   gfx::ImageSkia theme_l =
       gfx::ImageSkiaOperations::CreateMaskedImage(tab_l, *alpha->image_l);
   background_canvas.DrawImageInt(theme_l,
       0, 0, theme_l.width(), theme_l.height() - kToolbarOverlap,
       0, 0, theme_l.width(), theme_l.height() - kToolbarOverlap,
       false);
 
   // Draw right edge.  Again, don't draw over the toolbar.
-  gfx::ImageSkia tab_r = gfx::ImageSkiaOperations::CreateTiledImage(*tab_bg,
-      offset + width() - tab_image->r_width, bg_offset_y,
-      tab_image->r_width, height());
+  gfx::ImageSkia tab_r = TabUtil::CreateTiledInactiveBackground(tp,
+      background_id, background_overlay_id, background_offset_.y(),
+      offset + width() - tab_image->r_width, 0, tab_image->r_width, height());
   gfx::ImageSkia theme_r =
       gfx::ImageSkiaOperations::CreateMaskedImage(tab_r, *alpha->image_r);
   background_canvas.DrawImageInt(theme_r,
       0, 0, theme_r.width(), theme_r.height() - kToolbarOverlap,
       width() - theme_r.width(), 0, theme_r.width(),
       theme_r.height() - kToolbarOverlap, false);
 
   // Draw center.  Instead of masking out the top portion we simply skip over
-  // it by incrementing by GetDropShadowHeight(), since it's a simple
+  // it by incrementing by drop_shadow_height(), since it's a simple
   // rectangle. And again, don't draw over the toolbar.
-  background_canvas.TileImageInt(*tab_bg,
-     offset + tab_image->l_width,
-     bg_offset_y + drop_shadow_height(),
-     tab_image->l_width,
-     drop_shadow_height(),
-     width() - tab_image->l_width - tab_image->r_width,
-     height() - drop_shadow_height() - kToolbarOverlap);
+  gfx::ImageSkia tab_c = TabUtil::CreateTiledInactiveBackground(tp,
+      background_id,
+      background_overlay_id,
+      background_offset_.y(),
+      offset + tab_image->l_width,
+      drop_shadow_height(),
+      width() - tab_image->l_width - tab_image->r_width,
+      height() - drop_shadow_height() - kToolbarOverlap);
+  background_canvas.DrawImageInt(tab_c, tab_image->l_width,
+      drop_shadow_height());
 
   canvas->DrawImageInt(
       gfx::ImageSkia(background_canvas.ExtractImageRep()), 0, 0);
 
-  if (!GetThemeProvider()->HasCustomImage(tab_id) &&
+  if (!tp->HasCustomImage(background_overlay_id) &&
       hover_controller_.ShouldDraw()) {
     hover_controller_.Draw(canvas, gfx::ImageSkia(
         background_canvas.ExtractImageRep()));
   }
 
   // Now draw the highlights/shadows around the tab edge.
   canvas->DrawImageInt(*tab_inactive_image->image_l, 0, 0);
   canvas->TileImageInt(*tab_inactive_image->image_c,
                        tab_inactive_image->l_width, 0,
                        width() - tab_inactive_image->l_width -
@@ skipping 146 matching lines @@
     gfx::ImageSkia projection_glow(
         *tp->GetImageSkiaNamed(IDR_TAB_CAPTURE_GLOW));
     DrawIconCenter(canvas, projection_glow, 0, projection_glow.width(),
                    projection_glow.height(), glow_bounds, false, paint);
   } else if (data().capture_state == TabRendererData::CAPTURE_STATE_RECORDING) {
     // If recording, fade the recording icon on top of the favicon with a mask
     // around/behind it.
     gfx::ImageSkia recording_dot(*tp->GetImageSkiaNamed(IDR_TAB_RECORDING));
     gfx::ImageSkia recording_dot_mask(
         *tp->GetImageSkiaNamed(IDR_TAB_RECORDING_MASK));
-    gfx::ImageSkia tab_background;
-    if (IsActive()) {
-      tab_background = *tp->GetImageSkiaNamed(IDR_THEME_TOOLBAR);
-    } else {
-      int tab_id;
-      int frame_id_dummy;
-      views::Widget* widget = GetWidget();
-      GetTabIdAndFrameId(widget, &tab_id, &frame_id_dummy);
-      tab_background = *tp->GetImageSkiaNamed(tab_id);
-    }
 
     // This is the offset from the favicon bottom right corner for the mask,
     // given that the recording dot is drawn in the bottom right corner.
     int mask_offset_from_right = recording_dot.width() +
         (recording_dot_mask.width() - recording_dot.width()) / 2;
     int mask_offset_from_bottom = recording_dot.height() +
         (recording_dot_mask.height() - recording_dot.height()) / 2;
 
     int mask_dst_x = bounds.x() + bounds.width() - mask_offset_from_right;
     int mask_dst_y = bounds.y() + bounds.height() - mask_offset_from_bottom;
 
     // Crop the background image at the correct position and create a mask
     // from the background.
     int offset_x = GetMirroredX() + background_offset_.x() + mask_dst_x;
     int offset_y = mask_dst_y;
-    gfx::ImageSkia tab_background_cropped =
-        gfx::ImageSkiaOperations::CreateTiledImage(
-            tab_background, offset_x, offset_y,
-            recording_dot_mask.width(), recording_dot_mask.height());
+    gfx::ImageSkia tab_background_cropped;
+    if (IsActive()) {
+      gfx::ImageSkia tab_background = *tp->GetImageSkiaNamed(IDR_THEME_TOOLBAR);
+      tab_background_cropped =
+          gfx::ImageSkiaOperations::CreateTiledImage(
+              tab_background, offset_x, offset_y,
+              recording_dot_mask.width(), recording_dot_mask.height());
+    } else {
+      int background_id;
+      int background_overlay_id;
+      views::Widget* widget = GetWidget();
+      GetInactiveBackgroundIdAndOverlayId(widget, &background_id,
+          &background_overlay_id);
+
+      tab_background_cropped = TabUtil::CreateTiledInactiveBackground(tp,
+          background_id, background_overlay_id, background_offset_.y(),
+          offset_x, offset_y, recording_dot_mask.width(),
+          recording_dot_mask.height());
+    }
     gfx::ImageSkia recording_dot_mask_with_bg =
         gfx::ImageSkiaOperations::CreateMaskedImage(tab_background_cropped,
                                                     recording_dot_mask);
 
     // Draw the mask.
     DrawIconAtLocation(canvas, recording_dot_mask_with_bg, 0,
                        mask_dst_x, mask_dst_y,
                        recording_dot_mask.width(),
                        recording_dot_mask.height(),
                        false, SkPaint());
 
     // Potentially draw an alpha of the active bg image.
     double throb_value = GetThrobValue();
     if (!IsActive() && throb_value > 0) {
-      tab_background = *tp->GetImageSkiaNamed(IDR_THEME_TOOLBAR);
+      gfx::ImageSkia tab_background =
+          *tp->GetImageSkiaNamed(IDR_THEME_TOOLBAR);
       tab_background_cropped = gfx::ImageSkiaOperations::CreateTiledImage(
           tab_background, offset_x, offset_y,
           recording_dot_mask.width(), recording_dot_mask.height());
       recording_dot_mask_with_bg = gfx::ImageSkiaOperations::CreateMaskedImage(
           tab_background_cropped, recording_dot_mask);
 
       canvas->SaveLayerAlpha(static_cast<int>(throb_value * 0xff),
                              GetLocalBounds());
       DrawIconAtLocation(canvas, recording_dot_mask_with_bg, 0,
                          mask_dst_x, mask_dst_y,
@@ skipping 184 matching lines @@
   // The main bar is as wide as the normal tab's horizontal top line.
   // This top line of the tab extends a few pixels left and right of the
   // center image due to pixels in the rounded corner images.
   const int kBarPadding = 1;
   int main_bar_left = tab_active_.l_width - kBarPadding;
   int main_bar_right = width() - tab_active_.r_width + kBarPadding;
   return gfx::Rect(
       main_bar_left, 0, main_bar_right - main_bar_left, kImmersiveBarHeight);
 }
 
-void Tab::GetTabIdAndFrameId(views::Widget* widget,
-                             int* tab_id,
-                             int* frame_id) const {
+void Tab::GetInactiveBackgroundIdAndOverlayId(
+    views::Widget* widget,
+    int* background_id,
+    int* background_overlay_id) const {
   if (widget && widget->GetTopLevelWidget()->ShouldUseNativeFrame()) {
-    *tab_id = IDR_THEME_TAB_BACKGROUND_V;
-    *frame_id = 0;
+    *background_id = IDR_THEME_TAB_BACKGROUND_V;
+    *background_overlay_id = IDR_THEME_TAB_BACKGROUND_V_OVERLAY;
   } else if (data().incognito) {
-    *tab_id = IDR_THEME_TAB_BACKGROUND_INCOGNITO;
-    *frame_id = IDR_THEME_FRAME_INCOGNITO;
+    *background_id = IDR_THEME_TAB_BACKGROUND_INCOGNITO;
+    *background_overlay_id = IDR_THEME_TAB_BACKGROUND_INCOGNITO_OVERLAY;
 #if defined(OS_WIN)
   } else if (win8::IsSingleWindowMetroMode()) {
-    *tab_id = IDR_THEME_TAB_BACKGROUND_V;
-    *frame_id = 0;
+    *background_id = IDR_THEME_TAB_BACKGROUND_V;
+    *background_overlay_id = IDR_THEME_TAB_BACKGROUND_V_OVERLAY;
 #endif
   } else {
-    *tab_id = IDR_THEME_TAB_BACKGROUND;
-    *frame_id = IDR_THEME_FRAME;
+    *background_id = IDR_THEME_TAB_BACKGROUND;
+    *background_overlay_id = IDR_THEME_TAB_BACKGROUND_OVERLAY;
   }
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // Tab, private static:
 
 // static
 void Tab::InitTabResources() {
   static bool initialized = false;
   if (initialized)
@@ skipping 52 matching lines @@
                          const gfx::ImageSkia& image) {
   DCHECK_NE(scale_factor, ui::SCALE_FACTOR_NONE);
   ImageCacheEntry entry;
   entry.resource_id = resource_id;
   entry.scale_factor = scale_factor;
   entry.image = image;
   image_cache_->push_front(entry);
   if (image_cache_->size() > kMaxImageCacheSize)
     image_cache_->pop_back();
 }