Proper rendering of stacked tabs for MD.

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 <stddef.h>
 #include <limits>
 #include <utility>
 
@@ skipping 106 matching lines @@
 const char kTabCloseButtonName[] = "TabCloseButton";
 
 ////////////////////////////////////////////////////////////////////////////////
 // ImageCacheEntryMetadata
 //
 // All metadata necessary to uniquely identify a cached image.
 struct ImageCacheEntryMetadata {
   ImageCacheEntryMetadata(int resource_id,
                           SkColor fill_color,
                           SkColor stroke_color,
+                          bool use_fill_and_stroke_images,
                           ui::ScaleFactor scale_factor,
                           const gfx::Size& size);
 
   ~ImageCacheEntryMetadata();
 
   bool operator==(const ImageCacheEntryMetadata& rhs) const;
 
   int resource_id;     // Only needed by pre-MD
   SkColor fill_color;  // Both colors only needed by MD
   SkColor stroke_color;
+  bool use_fill_and_stroke_images;
   ui::ScaleFactor scale_factor;
   gfx::Size size;
 };
 
-ImageCacheEntryMetadata::ImageCacheEntryMetadata(int resource_id,
-                                                 SkColor fill_color,
-                                                 SkColor stroke_color,
-                                                 ui::ScaleFactor scale_factor,
-                                                 const gfx::Size& size)
+ImageCacheEntryMetadata::ImageCacheEntryMetadata(
+    int resource_id,
+    SkColor fill_color,
+    SkColor stroke_color,
+    bool use_fill_and_stroke_images,
+    ui::ScaleFactor scale_factor,
+    const gfx::Size& size)
     : resource_id(resource_id),
       fill_color(fill_color),
       stroke_color(stroke_color),
+      use_fill_and_stroke_images(use_fill_and_stroke_images),
       scale_factor(scale_factor),
       size(size) {
   DCHECK_NE(ui::SCALE_FACTOR_NONE, scale_factor);
 
   // Some fields are only relevant for pre-MD vs. MD.  Erase the irrelevant ones
   // so they don't cause incorrect cache misses.
   // TODO(pkasting): Remove |resource_id| field when non-MD code is deleted.
   if (ui::MaterialDesignController::IsModeMaterial())
     resource_id = 0;
   else
     fill_color = stroke_color = SK_ColorTRANSPARENT;
 }
 
 ImageCacheEntryMetadata::~ImageCacheEntryMetadata() {}
 
 bool ImageCacheEntryMetadata::operator==(
     const ImageCacheEntryMetadata& rhs) const {
   return resource_id == rhs.resource_id && fill_color == rhs.fill_color &&
-         stroke_color == rhs.stroke_color && scale_factor == rhs.scale_factor &&
-         size == rhs.size;
+         stroke_color == rhs.stroke_color &&
+         use_fill_and_stroke_images == rhs.use_fill_and_stroke_images &&
+         scale_factor == rhs.scale_factor && size == rhs.size;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // ImageCacheEntry and cache management
 //
 // A cached image and the metadata used to generate it.
 struct ImageCacheEntry {
   ImageCacheEntry(const ImageCacheEntryMetadata& metadata,
-                  const gfx::ImageSkia& image);
+                  const gfx::ImageSkia& fill_image,
+                  const gfx::ImageSkia& stroke_image);
   ~ImageCacheEntry();
 
   ImageCacheEntryMetadata metadata;
-  gfx::ImageSkia image;
+  gfx::ImageSkia fill_image;
+  gfx::ImageSkia stroke_image;
 };
 
 ImageCacheEntry::ImageCacheEntry(const ImageCacheEntryMetadata& metadata,
-                                 const gfx::ImageSkia& image)
-    : metadata(metadata), image(image) {}
+                                 const gfx::ImageSkia& fill_image,
+                                 const gfx::ImageSkia& stroke_image)
+    : metadata(metadata), fill_image(fill_image), stroke_image(stroke_image) {}
 
 ImageCacheEntry::~ImageCacheEntry() {}
 
 typedef std::list<ImageCacheEntry> ImageCache;
 
 // As the majority of the tabs are inactive, and painting tabs is slowish,
 // we cache a handful of the inactive tab backgrounds here.
 static ImageCache* g_image_cache = nullptr;
 
 struct TabImages {
@@ skipping 341 matching lines @@
   void OnGestureEvent(ui::GestureEvent* event) override {
     // Consume all gesture events here so that the parent (Tab) does not
     // start consuming gestures.
     ImageButton::OnGestureEvent(event);
     event->SetHandled();
   }
 
   const char* GetClassName() const override { return kTabCloseButtonName; }
 
  private:
-  // Returns the rectangular bounds of parent tab's visible region in the
-  // local coordinate space of |this|.
-  gfx::Rect GetTabBounds() const {
-    gfx::Path tab_mask;
-    tab_->GetHitTestMask(&tab_mask);
-
-    gfx::RectF tab_bounds_f(gfx::SkRectToRectF(tab_mask.getBounds()));
-    views::View::ConvertRectToTarget(tab_, this, &tab_bounds_f);
-    return gfx::ToEnclosingRect(tab_bounds_f);
-  }
-
-  // Returns the rectangular bounds of the tab close button in the local
-  // coordinate space of |this|, not including clipped regions on the top
-  // or bottom of the button. |tab_bounds| is the rectangular bounds of
-  // the parent tab's visible region in the local coordinate space of |this|.
-  gfx::Rect GetTabCloseButtonBounds(const gfx::Rect& tab_bounds) const {
-    gfx::Rect button_bounds(GetContentsBounds());
-    button_bounds.set_x(GetMirroredXForRect(button_bounds));
-
-    int top_overflow = tab_bounds.y() - button_bounds.y();
-    int bottom_overflow = button_bounds.bottom() - tab_bounds.bottom();
-    if (top_overflow > 0)
-      button_bounds.set_y(tab_bounds.y());
-    else if (bottom_overflow > 0)
-      button_bounds.set_height(button_bounds.height() - bottom_overflow);
-
-    return button_bounds;
-  }
-
   // views::MaskedTargeterDelegate:
   View* TargetForRect(View* root, const gfx::Rect& rect) override {
     CHECK_EQ(root, this);
 
     if (!views::UsePointBasedTargeting(rect))
       return ViewTargeterDelegate::TargetForRect(root, rect);
 
     // Ignore the padding set on the button.
     gfx::Rect contents_bounds = GetContentsBounds();
     contents_bounds.set_x(GetMirroredXForRect(contents_bounds));
 
 #if defined(USE_AURA)
     // Include the padding in hit-test for touch events.
     // TODO(pkasting): It seems like touch events would generate rects rather
     // than points and thus use the TargetForRect() call above.  If this is
     // reached, it may be from someone calling GetEventHandlerForPoint() while a
     // touch happens to be occurring.  In such a case, maybe we don't want this
     // code to run?  It's possible this block should be removed, or maybe this
     // whole function deleted.
     if (aura::Env::GetInstance()->is_touch_down())
       contents_bounds = GetLocalBounds();
 #endif
 
     return contents_bounds.Intersects(rect) ? this : parent();
   }
 
   // We need to define this so hit-testing won't include the border region.
   bool GetHitTestMask(gfx::Path* mask) const override {
-    DCHECK(mask);
-    mask->reset();
+    gfx::Rect button_bounds(GetContentsBounds());
+    button_bounds.set_x(GetMirroredXForRect(button_bounds));
+    mask->addRect(gfx::RectToSkRect(button_bounds));
 
-    // The parent tab may be partially occluded by another tab if we are
-    // in stacked tab mode, which means that the tab close button may also
-    // be partially occluded. Define the hit test mask of the tab close
-    // button to be the intersection of the parent tab's visible bounds
-    // and the bounds of the tab close button.
-    gfx::Rect tab_bounds(GetTabBounds());
-    gfx::Rect button_bounds(GetTabCloseButtonBounds(tab_bounds));
-    gfx::Rect intersection(gfx::IntersectRects(tab_bounds, button_bounds));
-
-    if (!intersection.IsEmpty()) {
-      mask->addRect(RectToSkRect(intersection));
-      return true;
-    }
-
-    return false;
-  }
-
-  bool DoesIntersectRect(const View* target,
-                         const gfx::Rect& rect) const override {
-    CHECK_EQ(target, this);
-
-    // If the request is not made in response to a gesture, use the
-    // default implementation.
-    if (views::UsePointBasedTargeting(rect))
-      return MaskedTargeterDelegate::DoesIntersectRect(target, rect);
-
-    // The hit test request is in response to a gesture. Return false if any
-    // part of the tab close button is hidden from the user.
-    // TODO(tdanderson): Consider always returning the intersection if the
-    //                   non-rectangular shape of the tab can be accounted for.
-    gfx::Rect tab_bounds(GetTabBounds());
-    gfx::Rect button_bounds(GetTabCloseButtonBounds(tab_bounds));
-    if (!tab_bounds.Contains(button_bounds))
-      return false;
-
-    return MaskedTargeterDelegate::DoesIntersectRect(target, rect);
+    // Clip against the tab mask in case the close button is party occluded due
+    // to stacking tabs.
+    // TODO(pkasting): Does this actually improve event targeting over using the
+    // full close button bounds?
+    gfx::Path clip;
+    tab_->GetHitTestMask(&clip);
+    gfx::Point origin;
+    ConvertPointToTarget(tab_, this, &origin);
+    clip.offset(SkIntToScalar(origin.x()), SkIntToScalar(origin.y()));
+    Op(*mask, clip, kIntersect_SkPathOp, mask);
+    return !mask->isEmpty();
   }
 
   Tab* tab_;
 
   DISALLOW_COPY_AND_ASSIGN(TabCloseButton);
 };
 
 ////////////////////////////////////////////////////////////////////////////////
 // ThrobberView
 //
@@ skipping 374 matching lines @@
 // Tab, views::MaskedTargeterDelegate overrides:
 
 bool Tab::GetHitTestMask(gfx::Path* mask) const {
   const float scale = GetWidget()->GetCompositor()->device_scale_factor();
   // When the window is maximized we don't want to shave off the edges or top
   // shadow of the tab, such that the user can click anywhere along the top
   // edge of the screen to select a tab. Ditto for immersive fullscreen.
   const views::Widget* widget = GetWidget();
   const bool extend_to_top =
       widget && (widget->IsMaximized() || widget->IsFullscreen());
-  *mask = GetBorderPath(scale, true, extend_to_top, size());
+  auto border_getter = base::Bind(&GetBorderPath, scale, true, extend_to_top);

[sky, 2016/08/04 23:42:08]

tricky

+  *mask = border_getter.Run(size());
 
-  // It is possible for a portion of the tab to be occluded if tabs are
-  // stacked, so modify the hit test mask to only include the visible
-  // region of the tab.
-  gfx::Rect clip;
-  controller_->ShouldPaintTab(this, &clip);
-  if (clip.size().GetArea()) {
-    SkRect intersection(mask->getBounds());
-    mask->reset();
-    if (!intersection.intersect(RectToSkRect(clip)))
-       return false;
-    mask->addRect(intersection);
-  }
-  return true;
+  // Clip the hittest mask if necessary for stacked tabs.  This is primarily so
+  // we can use the clipped mask to clip the close button mask.
+  // TODO(pkasting): Would it improve event targeting to do this clipping when
+  // not stacking tabs as well?
+  gfx::Path clip;
+  controller_->ShouldPaintTab(this, border_getter, &clip);
+  Op(*mask, clip, kDifference_SkPathOp, mask);
+  return !mask->isEmpty();
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // Tab, views::View overrides:
 
 void Tab::ViewHierarchyChanged(const ViewHierarchyChangedDetails& details) {
   // If this hierarchy changed has resulted in us being part of a widget
   // hierarchy for the first time, we can now get at the theme provider, and
   // should recalculate the button color.
   if (details.is_add)
     OnButtonColorMaybeChanged();
 }
 
 void Tab::OnPaint(gfx::Canvas* canvas) {
   // Don't paint if we're narrower than we can render correctly. (This should
   // only happen during animations).
   if (width() < GetMinimumInactiveSize().width() && !data().pinned)
     return;
 
-  gfx::Rect clip;
-  if (!controller_->ShouldPaintTab(this, &clip))
+  gfx::Path clip;
+  if (!controller_->ShouldPaintTab(
+          this, base::Bind(&GetBorderPath, canvas->image_scale(), true, false),
+          &clip))
     return;
-  if (!clip.IsEmpty()) {
-    canvas->Save();
-    canvas->ClipRect(clip);
-  }
 
   if (controller_->IsImmersiveStyle())
     PaintImmersiveTab(canvas);
   else
-    PaintTab(canvas);
-
-  if (!clip.IsEmpty())
-    canvas->Restore();
+    PaintTab(canvas, clip);
 }
 
 void Tab::Layout() {
   const gfx::Rect lb = GetContentsBounds();
   showing_icon_ = ShouldShowIcon();
   // See comments in IconCapacity().
   const int extra_padding =
       (controller_->ShouldHideCloseButtonForInactiveTabs() ||
        (IconCapacity() < 3)) ? 0 : kExtraLeftPaddingToBalanceCloseButtonPadding;
   const int start = lb.x() + extra_padding;
@@ skipping 266 matching lines @@
 
   if (data().blocked == old.blocked)
     return;
 
   if (data().blocked)
     StartPulse();
   else
     StopPulse();
 }
 
-void Tab::PaintTab(gfx::Canvas* canvas) {
+void Tab::PaintTab(gfx::Canvas* canvas, const gfx::Path& clip) {
   const int kActiveTabFillId = IDR_THEME_TOOLBAR;
   const bool has_custom_image =
       GetThemeProvider()->HasCustomImage(kActiveTabFillId);
   const int y_offset = -GetYInsetForActiveTabBackground();
   if (IsActive()) {
-    PaintTabBackgroundUsingFillId(canvas, true, kActiveTabFillId,
+    PaintTabBackgroundUsingFillId(canvas, canvas, true, kActiveTabFillId,
                                   has_custom_image, y_offset);
   } else {
-    PaintInactiveTabBackground(canvas);
+    PaintInactiveTabBackground(canvas, clip);
 
     const double throb_value = GetThrobValue();
     if (throb_value > 0) {
       canvas->SaveLayerAlpha(gfx::ToRoundedInt(throb_value * 0xff),
                              GetLocalBounds());
-      PaintTabBackgroundUsingFillId(canvas, true, kActiveTabFillId,
+      PaintTabBackgroundUsingFillId(canvas, canvas, true, kActiveTabFillId,
                                     has_custom_image, y_offset);
       canvas->Restore();
     }
   }
 
   if (showing_icon_)
     PaintIcon(canvas);
 }
 
 void Tab::PaintImmersiveTab(gfx::Canvas* canvas) {
@@ skipping 33 matching lines @@
       canvas->FillRect(right_eye_rect, kEyeColor);
       // The second part parts the remaining |eye_width| on the left.
       int left_eye_width = eye_offset + eye_width - bar_rect.width();
       gfx::Rect left_eye_rect(
           bar_rect.x(), 0, left_eye_width, kImmersiveBarHeight);
       canvas->FillRect(left_eye_rect, kEyeColor);
     }
   }
 }
 
-void Tab::PaintInactiveTabBackground(gfx::Canvas* canvas) {
+void Tab::PaintInactiveTabBackground(gfx::Canvas* canvas,
+                                     const gfx::Path& clip) {
   bool has_custom_image;
   int fill_id = controller_->GetBackgroundResourceId(&has_custom_image);
 
   // 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.  Note that if the theme is
   // only providing a custom frame image, |has_custom_image| will be true, but
   // we should use the |background_offset_| here.
   const ui::ThemeProvider* tp = GetThemeProvider();
   const int y_offset = tp->HasCustomImage(fill_id) ?
       -GetLayoutConstant(TAB_TOP_EXCLUSION_HEIGHT) : background_offset_.y();
 
   // We only cache the image when it's the default image and we're not hovered,
   // to avoid caching a background image that isn't the same for all tabs.
   if (has_custom_image || hover_controller_.ShouldDraw()) {
-    PaintTabBackgroundUsingFillId(canvas, false, fill_id, has_custom_image,
-                                  y_offset);
+    PaintTabBackgroundUsingFillId(canvas, canvas, false, fill_id,
+                                  has_custom_image, y_offset);
     return;
   }
 
+  // For efficiency, we don't use separate fill and stroke images unless we
+  // really need to clip the stroke and not the fill (for stacked tabs).  This
+  // saves memory and avoids an extra image draw at the cost of recalculating
+  // the images when MaySetClip() toggles.
+  const bool use_fill_and_stroke_images =
+      controller_->MaySetClip() &&
+      ui::MaterialDesignController::IsModeMaterial();
+
   const ImageCacheEntryMetadata metadata(
       fill_id, tp->GetColor(ThemeProperties::COLOR_BACKGROUND_TAB),
-      controller_->GetToolbarTopSeparatorColor(),
+      controller_->GetToolbarTopSeparatorColor(), use_fill_and_stroke_images,
       ui::GetSupportedScaleFactor(canvas->image_scale()), size());
   auto it = std::find_if(
       g_image_cache->begin(), g_image_cache->end(),
       [&metadata](const ImageCacheEntry& e) { return e.metadata == metadata; });
   if (it == g_image_cache->end()) {
     gfx::Canvas tmp_canvas(size(), canvas->image_scale(), false);
-    PaintTabBackgroundUsingFillId(&tmp_canvas, false, fill_id, false, y_offset);
-    g_image_cache->emplace_front(metadata,
-                                 gfx::ImageSkia(tmp_canvas.ExtractImageRep()));
+    if (use_fill_and_stroke_images) {
+      gfx::Canvas tmp_fill_canvas(size(), canvas->image_scale(), false);
+      PaintTabBackgroundUsingFillId(&tmp_fill_canvas, &tmp_canvas, false,
+                                    fill_id, false, y_offset);
+      g_image_cache->emplace_front(
+          metadata, gfx::ImageSkia(tmp_fill_canvas.ExtractImageRep()),
+          gfx::ImageSkia(tmp_canvas.ExtractImageRep()));
+    } else {
+      PaintTabBackgroundUsingFillId(&tmp_canvas, &tmp_canvas, false, fill_id,
+                                    false, y_offset);
+      g_image_cache->emplace_front(
+          metadata, gfx::ImageSkia(),
+          gfx::ImageSkia(tmp_canvas.ExtractImageRep()));
+    }
     if (g_image_cache->size() > kMaxImageCacheSize)
       g_image_cache->pop_back();
     it = g_image_cache->begin();
   }
-  canvas->DrawImageInt(it->image, 0, 0);
+
+  gfx::ScopedCanvas scoped_canvas(
+      use_fill_and_stroke_images ? canvas : nullptr);
+  if (use_fill_and_stroke_images) {
+    canvas->DrawImageInt(it->fill_image, 0, 0);
+    canvas->sk_canvas()->clipPath(clip, SkRegion::kDifference_Op, true);
+  }
+  canvas->DrawImageInt(it->stroke_image, 0, 0);
 }
 
-void Tab::PaintTabBackgroundUsingFillId(gfx::Canvas* canvas,
+void Tab::PaintTabBackgroundUsingFillId(gfx::Canvas* fill_canvas,
+                                        gfx::Canvas* stroke_canvas,
                                         bool is_active,
                                         int fill_id,
                                         bool has_custom_image,
                                         int y_offset) {
   const ui::ThemeProvider* tp = GetThemeProvider();
   const SkColor toolbar_color = tp->GetColor(ThemeProperties::COLOR_TOOLBAR);
   gfx::ImageSkia* fill_image = tp->GetImageSkiaNamed(fill_id);
   // The tab image needs to be lined up with the background image
   // so that it feels partially transparent.  These offsets represent the tab
   // position within the frame background image.
   const int x_offset = GetMirroredX() + background_offset_.x();
 
   const SkScalar kMinHoverRadius = 16;
   const SkScalar radius =
       std::max(SkFloatToScalar(width() / 4.f), kMinHoverRadius);
   const bool draw_hover = !is_active && hover_controller_.ShouldDraw();
   SkPoint hover_location(gfx::PointToSkPoint(hover_controller_.location()));
   const SkColor hover_color =
       SkColorSetA(toolbar_color, hover_controller_.GetAlpha());
 
   if (ui::MaterialDesignController::IsModeMaterial()) {
-    gfx::ScopedCanvas scoped_canvas(canvas);
-    const float scale = canvas->UndoDeviceScaleFactor();
+    gfx::Path fill;
+    SkPaint paint;
+    paint.setAntiAlias(true);
 
     // Draw the fill.
-    gfx::Path fill = GetFillPath(scale, size());
-    SkPaint paint;
-    paint.setAntiAlias(true);
     {
-      gfx::ScopedCanvas clip_scoper(canvas);
-      canvas->ClipPath(fill, true);
-      if (has_custom_image) {
-        gfx::ScopedCanvas scale_scoper(canvas);
-        canvas->sk_canvas()->scale(scale, scale);
-        canvas->TileImageInt(*fill_image, x_offset, y_offset, 0, 0, width(),
-                             height());
-      } else {
-        paint.setColor(
-            is_active ? toolbar_color
-                      : tp->GetColor(ThemeProperties::COLOR_BACKGROUND_TAB));
-        canvas->DrawRect(gfx::ScaleToEnclosingRect(GetLocalBounds(), scale),
-                         paint);
-      }
-      if (draw_hover) {
-        hover_location.scale(SkFloatToScalar(scale));
-        DrawHighlight(canvas, hover_location, radius * scale, hover_color);
+      gfx::ScopedCanvas scoped_fill_canvas(fill_canvas);
+      const float scale = fill_canvas->UndoDeviceScaleFactor();
+
+      fill = GetFillPath(scale, size());
+      {
+        gfx::ScopedCanvas clip_scoper(fill_canvas);
+        fill_canvas->ClipPath(fill, true);
+        if (has_custom_image) {
+          gfx::ScopedCanvas scale_scoper(fill_canvas);
+          fill_canvas->sk_canvas()->scale(scale, scale);
+          fill_canvas->TileImageInt(*fill_image, x_offset, y_offset, 0, 0,
+                                    width(), height());
+        } else {
+          paint.setColor(
+              is_active ? toolbar_color
+                        : tp->GetColor(ThemeProperties::COLOR_BACKGROUND_TAB));
+          fill_canvas->DrawRect(
+              gfx::ScaleToEnclosingRect(GetLocalBounds(), scale), paint);
+        }
+        if (draw_hover) {
+          hover_location.scale(SkFloatToScalar(scale));
+          DrawHighlight(fill_canvas, hover_location, radius * scale,
+                        hover_color);
+        }
       }
     }
 
     // Draw the stroke.
-    gfx::Path stroke = GetBorderPath(scale, false, false, size());
-    Op(stroke, fill, kDifference_SkPathOp, &stroke);
-    if (!is_active) {
-      // Clip out the bottom line; this will be drawn for us by
-      // TabStrip::PaintChildren().
-      canvas->ClipRect(gfx::RectF(width() * scale, height() * scale - 1));
+    {
+      gfx::ScopedCanvas scoped_stroke_canvas(stroke_canvas);
+      const float scale = stroke_canvas->UndoDeviceScaleFactor();
+
+      gfx::Path stroke = GetBorderPath(scale, false, false, size());
+      Op(stroke, fill, kDifference_SkPathOp, &stroke);
+      if (!is_active) {
+        // Clip out the bottom line; this will be drawn for us by
+        // TabStrip::PaintChildren().
+        stroke_canvas->ClipRect(gfx::RectF(width() * scale,
+                                           height() * scale - 1));
+      }
+      paint.setColor(controller_->GetToolbarTopSeparatorColor());
+      stroke_canvas->DrawPath(stroke, paint);
     }
-    paint.setColor(controller_->GetToolbarTopSeparatorColor());
-    canvas->DrawPath(stroke, paint);
   } else {
+    gfx::Canvas* canvas = stroke_canvas;
     if (draw_hover) {
       // Draw everything to a temporary canvas so we can extract an image for
       // use in masking the hover glow.
       gfx::Canvas background_canvas(size(), canvas->image_scale(), false);
       PaintTabFill(&background_canvas, fill_image, x_offset, y_offset, size(),
                    is_active);
       gfx::ImageSkia background_image(background_canvas.ExtractImageRep());
       canvas->DrawImageInt(background_image, 0, 0);
 
       gfx::Canvas hover_canvas(size(), canvas->image_scale(), false);
@@ skipping 256 matching lines @@
 gfx::Rect Tab::GetImmersiveBarRect() const {
   // 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 = g_active_images.l_width - kBarPadding;
   int main_bar_right = width() - g_active_images.r_width + kBarPadding;
   return gfx::Rect(
       main_bar_left, 0, main_bar_right - main_bar_left, kImmersiveBarHeight);
 }