Fix pixelation of tab borders when device scale changes (abandoned)

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 26 matching lines @@
 #include "ui/base/material_design/material_design_controller.h"
 #include "ui/base/models/list_selection_model.h"
 #include "ui/base/resource/resource_bundle.h"
 #include "ui/base/theme_provider.h"
 #include "ui/gfx/animation/animation_container.h"
 #include "ui/gfx/animation/throb_animation.h"
 #include "ui/gfx/canvas.h"
 #include "ui/gfx/color_analysis.h"
 #include "ui/gfx/favicon_size.h"
 #include "ui/gfx/geometry/rect_conversions.h"
+#include "ui/gfx/image/canvas_image_source.h"
 #include "ui/gfx/image/image_skia_operations.h"
 #include "ui/gfx/paint_vector_icon.h"
 #include "ui/gfx/path.h"
 #include "ui/gfx/scoped_canvas.h"
 #include "ui/gfx/skia_util.h"
 #include "ui/gfx/vector_icons_public.h"
 #include "ui/resources/grit/ui_resources.h"
 #include "ui/views/border.h"
 #include "ui/views/controls/button/image_button.h"
 #include "ui/views/controls/label.h"
@@ skipping 57 matching lines @@
 // Number of steps in the immersive mode loading animation.
 const int kImmersiveLoadingStepCount = 32;
 
 const char kTabCloseButtonName[] = "TabCloseButton";
 
 // Desaturate favicon HSL shift values.
 const double kDesaturateHue = -1.0;
 const double kDesaturateSaturation = 0.0;
 const double kDesaturateLightness = 0.6;
 
-// Parameters for PaintTabBackgroundUsingParams().
+// Parameters for PaintTabFill/StrokeUsingParams().
 struct PaintBackgroundParams {
   PaintBackgroundParams(bool is_active,
-                        gfx::ImageSkia* fill_image_ptr,
+                        gfx::ImageSkia* fill_image,
                         bool has_custom_image,
-                        gfx::Rect rect,
+                        const gfx::Rect& rect,
                         SkColor stroke_color,
                         SkColor toolbar_color,
-                        SkColor background_tab_color)
+                        SkColor background_tab_color,
+                        bool draw_hover,
+                        const gfx::Point& hover_location,
+                        SkAlpha hover_alpha)
       : is_active(is_active),
-        fill_image(fill_image_ptr ? *fill_image_ptr : gfx::ImageSkia()),
-        has_custom_image(has_custom_image),
+        fill_image(fill_image ? *fill_image : gfx::ImageSkia()),
         rect(rect),
         stroke_color(stroke_color),
         toolbar_color(toolbar_color),
-        background_tab_color(background_tab_color) {}
+        background_tab_color(background_tab_color),
+        draw_hover(draw_hover),
+        hover_location(PointToSkPoint(hover_location)),
+        hover_alpha(hover_alpha) {}
 
   const bool is_active;
   const gfx::ImageSkia fill_image;
-  const bool has_custom_image;
   const gfx::Rect rect;
   const SkColor stroke_color;
   const SkColor toolbar_color;
   const SkColor background_tab_color;
+  const bool draw_hover;
+  const SkPoint hover_location;
+  const SkAlpha hover_alpha;
 };
 
+void PaintTabFillUsingParams(gfx::Canvas* canvas,
+                             const PaintBackgroundParams& params);
+
+void PaintTabStrokeUsingParams(gfx::Canvas* canvas,
+                               const PaintBackgroundParams& params);
+
+////////////////////////////////////////////////////////////////////////////////
+// TabImageSource
+//
+// This subclass of CanvasImageSource allows the inactive tab image to be cached
+// once for each requested scale factor.
+class TabImageSource : public gfx::CanvasImageSource {
+ public:
+  enum UseCanvas { FILL, STROKE, BOTH };
+
+  TabImageSource(UseCanvas use_canvas, Tab* tab, int fill_id, int y_offset);
+  ~TabImageSource() override {}
+
+  // gfx::CanvasImageSource override.
+  void Draw(gfx::Canvas* canvas) override;
+  bool HasRepresentationAtAllScales() const override { return true; }
+
+ private:
+  const UseCanvas use_canvas_;
+  const PaintBackgroundParams params_;
+
+  DISALLOW_COPY_AND_ASSIGN(TabImageSource);
+};
+
+TabImageSource::TabImageSource(UseCanvas use_canvas,
+                               Tab* tab,
+                               int fill_id,
+                               int y_offset)
+    : gfx::CanvasImageSource(tab->size(), true),
+      use_canvas_(use_canvas),
+      params_(false,
+              tab->GetThemeProvider()->GetImageSkiaNamed(fill_id),
+              false,
+              gfx::Rect(gfx::Point(0, y_offset), tab->size()),
+              tab->controller()->GetToolbarTopSeparatorColor(),
+              tab->GetThemeProvider()->GetColor(ThemeProperties::COLOR_TOOLBAR),
+              tab->GetThemeProvider()->GetColor(
+                  ThemeProperties::COLOR_BACKGROUND_TAB),
+              false,
+              gfx::Point(),
+              255) {}
+
+void TabImageSource::Draw(gfx::Canvas* canvas) {
+  if (use_canvas_ != STROKE)
+    PaintTabFillUsingParams(canvas, params_);
+  if (use_canvas_ != FILL)
+    PaintTabStrokeUsingParams(canvas, params_);
+}
+
 ////////////////////////////////////////////////////////////////////////////////
 // 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,
     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 &&
          use_fill_and_stroke_images == rhs.use_fill_and_stroke_images &&
-         scale_factor == rhs.scale_factor && size == rhs.size;
+         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& fill_image,
-                  const gfx::ImageSkia& stroke_image);
+                  Tab* tab,
+                  int fill_id,
+                  int y_offset);
   ~ImageCacheEntry();
 
   ImageCacheEntryMetadata metadata;
   gfx::ImageSkia fill_image;
   gfx::ImageSkia stroke_image;
 };
 
 ImageCacheEntry::ImageCacheEntry(const ImageCacheEntryMetadata& metadata,
-                                 const gfx::ImageSkia& fill_image,
-                                 const gfx::ImageSkia& stroke_image)
-    : metadata(metadata), fill_image(fill_image), stroke_image(stroke_image) {}
+                                 Tab* tab,
+                                 int fill_id,
+                                 int y_offset)
+    : metadata(metadata) {
+  if (metadata.use_fill_and_stroke_images) {
+    fill_image = gfx::ImageSkia(
+        new TabImageSource(TabImageSource::FILL, tab, fill_id, y_offset),
+        tab->size());
+  }
+  TabImageSource::UseCanvas use = metadata.use_fill_and_stroke_images
+                                      ? TabImageSource::STROKE
+                                      : TabImageSource::BOTH;
+  stroke_image = gfx::ImageSkia(new TabImageSource(use, tab, fill_id, y_offset),
+                                tab->size());
+}
 
 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 242 matching lines @@
                        theme_r.height() - toolbar_overlap, false);
 
   // Draw center.  Instead of masking out the top portion we simply skip over it
   // by incrementing by the top padding, since it's a simple rectangle.
   rect.Inset(g_mask_images.l_width, tab_insets.top(), g_mask_images.r_width,
              toolbar_overlap);
   canvas->TileImageInt(fill_image, rect.x(), rect.y(), g_mask_images.l_width,
                        tab_insets.top(), rect.width(), rect.height());
 }
 
-void PaintTabBackgroundUsingParams(gfx::Canvas* fill_canvas,
-                                   gfx::Canvas* stroke_canvas,
-                                   views::GlowHoverController* hc,
-                                   const PaintBackgroundParams& params) {
+// In non-MD mode, there is never a need to draw fill and stroke onto separate
+// canvases, so in that case, this function does both.
+void PaintTabFillUsingParams(gfx::Canvas* canvas,
+                             const PaintBackgroundParams& params) {
   const gfx::Rect& rect = params.rect;
   const SkScalar kMinHoverRadius = 16;
   const SkScalar radius =
       std::max(SkFloatToScalar(rect.width() / 4.f), kMinHoverRadius);
-  const bool draw_hover = !params.is_active && hc;
-  SkPoint hover_location(
-      gfx::PointToSkPoint(draw_hover ? hc->location() : gfx::Point()));
   const SkColor hover_color =
-      SkColorSetA(params.toolbar_color, draw_hover ? hc->GetAlpha() : 255);
+      SkColorSetA(params.toolbar_color, params.hover_alpha);
 
   if (ui::MaterialDesignController::IsModeMaterial()) {
-    gfx::Path fill;
-    SkPaint paint;
-    paint.setAntiAlias(true);
+    gfx::ScopedCanvas scoped_canvas(canvas);
+    const float scale = canvas->UndoDeviceScaleFactor();
+    gfx::Path fill = GetFillPath(scale, rect.size());
 
-    // Draw the fill.
     {
-      gfx::ScopedCanvas scoped_canvas(fill_canvas);
-      const float scale = fill_canvas->UndoDeviceScaleFactor();
-
-      fill = GetFillPath(scale, rect.size());
-      {
-        gfx::ScopedCanvas clip_scoper(fill_canvas);
-        fill_canvas->ClipPath(fill, true);
-        if (!params.fill_image.isNull()) {
-          gfx::ScopedCanvas scale_scoper(fill_canvas);
-          fill_canvas->sk_canvas()->scale(scale, scale);
-          fill_canvas->TileImageInt(params.fill_image, rect.x(), rect.y(), 0, 0,
-                                    rect.width(), rect.height());
-        } else {
-          paint.setColor(params.is_active ? params.toolbar_color
-                                          : params.background_tab_color);
-          fill_canvas->DrawRect(
-              gfx::ScaleToEnclosingRect(gfx::Rect(rect.size()), scale),
-              paint);
-        }
-        if (draw_hover) {
-          hover_location.scale(SkFloatToScalar(scale));
-          DrawHighlight(fill_canvas, hover_location, radius * scale,
-                        hover_color);
-        }
+      gfx::ScopedCanvas clip_scoper(canvas);
+      canvas->ClipPath(fill, true);
+      if (!params.fill_image.isNull()) {
+        gfx::ScopedCanvas scale_scoper(canvas);
+        canvas->sk_canvas()->scale(scale, scale);
+        canvas->TileImageInt(params.fill_image, rect.x(), rect.y(), 0, 0,
+                             rect.width(), rect.height());
+      } else {
+        SkPaint paint;
+        paint.setAntiAlias(true);
+        paint.setColor(params.is_active ? params.toolbar_color
+                                        : params.background_tab_color);
+        canvas->DrawRect(
+            gfx::ScaleToEnclosingRect(gfx::Rect(rect.size()), scale), paint);
+      }
+      if (params.draw_hover) {
+        DrawHighlight(canvas, params.hover_location * scale, radius * scale,
+                      hover_color);
       }
     }
-
-    // Draw the stroke.
-    {
-      gfx::ScopedCanvas scoped_canvas(stroke_canvas);
-      const float scale = stroke_canvas->UndoDeviceScaleFactor();
-
-      gfx::Path stroke = GetBorderPath(scale, false, false, rect.size());
-      Op(stroke, fill, kDifference_SkPathOp, &stroke);
-      if (!params.is_active) {
-        // Clip out the bottom line; this will be drawn for us by
-        // TabStrip::PaintChildren().
-        stroke_canvas->ClipRect(gfx::RectF(rect.width() * scale,
-                                           rect.height() * scale - 1));
-      }
-      paint.setColor(params.stroke_color);
-      stroke_canvas->DrawPath(stroke, paint);
-    }
   } else {
-    gfx::Canvas* canvas = stroke_canvas;
-    if (draw_hover) {
+    if (params.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(rect.size(), canvas->image_scale(), false);
       PaintTabFill(&background_canvas, params.fill_image, rect,
                    params.is_active);
       gfx::ImageSkia background_image(background_canvas.ExtractImageRep());
       canvas->DrawImageInt(background_image, 0, 0);
 
       gfx::Canvas hover_canvas(rect.size(), canvas->image_scale(), false);
-      DrawHighlight(&hover_canvas, hover_location, radius, hover_color);
+      DrawHighlight(&hover_canvas, params.hover_location, radius, hover_color);
       gfx::ImageSkia result = gfx::ImageSkiaOperations::CreateMaskedImage(
           gfx::ImageSkia(hover_canvas.ExtractImageRep()), background_image);
       canvas->DrawImageInt(result, 0, 0);
     } else {
       PaintTabFill(canvas, params.fill_image, rect, params.is_active);
     }
 
     // Now draw the stroke, highlights, and shadows around the tab edge.
     TabImages* stroke_images =
         params.is_active ? &g_active_images : &g_inactive_images;
     canvas->DrawImageInt(*stroke_images->image_l, 0, 0);
     canvas->TileImageInt(
         *stroke_images->image_c, stroke_images->l_width, 0,
         rect.width() - stroke_images->l_width - stroke_images->r_width,
         rect.height());
     canvas->DrawImageInt(*stroke_images->image_r,
                          rect.width() - stroke_images->r_width, 0);
   }
 }
 
+void PaintTabStrokeUsingParams(gfx::Canvas* canvas,
+                               const PaintBackgroundParams& params) {
+  DCHECK(ui::MaterialDesignController::IsModeMaterial());
+  gfx::ScopedCanvas scoped_canvas(canvas);
+  const float scale = canvas->UndoDeviceScaleFactor();
+
+  SkPaint paint;
+  paint.setAntiAlias(true);
+  gfx::Path stroke = GetBorderPath(scale, false, false, params.rect.size());
+  gfx::Path fill = GetFillPath(scale, params.rect.size());
+  Op(stroke, fill, kDifference_SkPathOp, &stroke);
+  if (!params.is_active) {
+    // Clip out the bottom line; this will be drawn for us by
+    // TabStrip::PaintChildren().
+    canvas->ClipRect(gfx::RectF(params.rect.width() * scale,
+                                params.rect.height() * scale - 1));
+  }
+  paint.setColor(params.stroke_color);
+  canvas->DrawPath(stroke, paint);
+}
+
 // Desaturates the favicon. Should only be used for when a tab encounters a
 // network error state.
 void PaintDesaturatedFavIcon(gfx::Canvas* canvas,
                              gfx::ImageSkia& favicon,
                              const gfx::Rect& bounds) {
   color_utils::HSL shift = {kDesaturateHue,
                             kDesaturateSaturation,
                             kDesaturateLightness};
   gfx::ImageSkia desaturated_favicon =
       gfx::ImageSkiaOperations::CreateHSLShiftedImage(favicon, shift);
@@ skipping 849 matching lines @@
   else
     StopPulse();
 }
 
 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, canvas, true, kActiveTabFillId,
+    PaintTabBackgroundUsingFillId(canvas, true, kActiveTabFillId,
                                   has_custom_image, y_offset);
   } else {
     PaintInactiveTabBackground(canvas, clip);
 
     const double throb_value = GetThrobValue();
     if (throb_value > 0) {
       canvas->SaveLayerAlpha(gfx::ToRoundedInt(throb_value * 0xff),
                              GetLocalBounds());
-      PaintTabBackgroundUsingFillId(canvas, canvas, true, kActiveTabFillId,
+      PaintTabBackgroundUsingFillId(canvas, true, kActiveTabFillId,
                                     has_custom_image, y_offset);
       canvas->Restore();
     }
   }
 
   if (showing_icon_)
     PaintIcon(canvas);
 }
 
 void Tab::PaintImmersiveTab(gfx::Canvas* canvas) {
@@ skipping 50 matching lines @@
   // 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, canvas, false, fill_id,
-                                  has_custom_image, y_offset);
+    PaintTabBackgroundUsingFillId(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(), use_fill_and_stroke_images,
-      ui::GetSupportedScaleFactor(canvas->image_scale()), size());
+      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);
-    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()));
-    }
+    g_image_cache->emplace_front(metadata, this, fill_id, y_offset);
     if (g_image_cache->size() > kMaxImageCacheSize)
       g_image_cache->pop_back();
     it = g_image_cache->begin();
   }
 
   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* fill_canvas,
-                                        gfx::Canvas* stroke_canvas,
+void Tab::PaintTabBackgroundUsingFillId(gfx::Canvas* canvas,
                                         bool is_active,
                                         int fill_id,
                                         bool has_custom_image,
                                         int y_offset) {
-  views::GlowHoverController* hc =
-      hover_controller_.ShouldDraw() ? &hover_controller_ : nullptr;
   gfx::ImageSkia* fill_image =
       has_custom_image || !ui::MaterialDesignController::IsModeMaterial()
           ? GetThemeProvider()->GetImageSkiaNamed(fill_id)
           : nullptr;
   // 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.
   gfx::Rect rect(GetLocalBounds());
   rect.Offset(GetMirroredX() + background_offset_.x(), y_offset);
   PaintBackgroundParams params(
       is_active, fill_image, has_custom_image, rect,
       controller_->GetToolbarTopSeparatorColor(),
       GetThemeProvider()->GetColor(ThemeProperties::COLOR_TOOLBAR),
-      GetThemeProvider()->GetColor(ThemeProperties::COLOR_BACKGROUND_TAB));
+      GetThemeProvider()->GetColor(ThemeProperties::COLOR_BACKGROUND_TAB),
+      !is_active && hover_controller_.ShouldDraw(),
+      hover_controller_.location(), hover_controller_.GetAlpha());
 
-  PaintTabBackgroundUsingParams(fill_canvas, stroke_canvas, hc, params);
+  PaintTabFillUsingParams(canvas, params);
+  PaintTabStrokeUsingParams(canvas, params);
 }
 
 void Tab::PaintPinnedTabTitleChangedIndicatorAndIcon(
     gfx::Canvas* canvas,
     const gfx::Rect& favicon_draw_bounds) {
   // The pinned tab title changed indicator consists of two parts:
   // . a clear (totally transparent) part over the bottom right (or left in rtl)
   //   of the favicon. This is done by drawing the favicon to a canvas, then
   //   drawing the clear part on top of the favicon.
   // . a circle in the bottom right (or left in rtl) of the favicon.
@@ skipping 240 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);
 }