Remove pre-MD code from browser/ui/views/tabs/tab.cc

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 16 matching lines @@
 #include "chrome/grit/generated_resources.h"
 #include "chrome/grit/theme_resources.h"
 #include "components/grit/components_scaled_resources.h"
 #include "components/strings/grit/components_strings.h"
 #include "content/public/browser/user_metrics.h"
 #include "content/public/common/url_constants.h"
 #include "third_party/skia/include/effects/SkGradientShader.h"
 #include "third_party/skia/include/pathops/SkPathOps.h"
 #include "ui/accessibility/ax_view_state.h"
 #include "ui/base/l10n/l10n_util.h"
-#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/image_skia_operations.h"
@@ skipping 40 matching lines @@
 const double kSelectedTabOpacity = 0.3;
 
 // Inactive selected tabs have their throb value scaled by this.
 const double kSelectedTabThrobScale = 0.95 - kSelectedTabOpacity;
 
 // Max number of images to cache. This has to be at least two since rounding
 // errors may lead to tabs in the same tabstrip having different sizes.
 // 8 = normal/incognito, active/inactive, 2 sizes within tabstrip.
 const size_t kMaxImageCacheSize = 8;
 
-// Height of the miniature tab strip in immersive mode.
-const int kImmersiveTabHeight = 3;
-
-// Height of the small tab indicator rectangles in immersive mode.
-const int kImmersiveBarHeight = 2;
-
-// Color for active and inactive tabs in the immersive mode light strip. These
-// should be a little brighter than the color of the normal art assets for tabs,
-// which for active tabs is 230, 230, 230 and for inactive is 184, 184, 184.
-const SkColor kImmersiveActiveTabColor = SkColorSetRGB(235, 235, 235);
-const SkColor kImmersiveInactiveTabColor = SkColorSetRGB(190, 190, 190);
-
-// The minimum opacity (out of 1) when a tab (either active or inactive) is
-// throbbing in the immersive mode light strip.
-const double kImmersiveTabMinThrobOpacity = 0.66;
-
-// Number of steps in the immersive mode loading animation.
-const int kImmersiveLoadingStepCount = 32;
-
 const char kTabCloseButtonName[] = "TabCloseButton";
 
 ////////////////////////////////////////////////////////////////////////////////
 // ImageCacheEntryMetadata
 //
 // All metadata necessary to uniquely identify a cached image.
 struct ImageCacheEntryMetadata {
-  ImageCacheEntryMetadata(int resource_id,
-                          SkColor fill_color,
+  ImageCacheEntryMetadata(SkColor fill_color,
                           SkColor stroke_color,
                           bool use_fill_and_stroke_images,
                           float 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 fill_color;
   SkColor stroke_color;
   bool use_fill_and_stroke_images;
   float scale_factor;
   gfx::Size size;
 };
 
 ImageCacheEntryMetadata::ImageCacheEntryMetadata(
-    int resource_id,
     SkColor fill_color,
     SkColor stroke_color,
     bool use_fill_and_stroke_images,
     float scale_factor,
     const gfx::Size& size)
-    : resource_id(resource_id),
-      fill_color(fill_color),
+    : fill_color(fill_color),
       stroke_color(stroke_color),
       use_fill_and_stroke_images(use_fill_and_stroke_images),
       scale_factor(scale_factor),
-      size(size) {
-  // 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;
-}
+      size(size) {}
 
 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 &&
+  return 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;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // ImageCacheEntry and cache management
 //
 // A cached image and the metadata used to generate it.
 struct ImageCacheEntry {
   ImageCacheEntry(const ImageCacheEntryMetadata& metadata,
@@ skipping 12 matching lines @@
     : 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 {
-  gfx::ImageSkia* image_l;
-  gfx::ImageSkia* image_c;
-  gfx::ImageSkia* image_r;
-  int l_width;
-  int r_width;
-};
-static TabImages g_active_images = {0};
-static TabImages g_inactive_images = {0};
-static TabImages g_mask_images = {0};
-
-// Loads the images to be used for the tab background.
-void LoadTabImages() {
-  g_image_cache->clear();
-
-  // We're not letting people override tab images just yet.
-  ui::ResourceBundle& rb = ui::ResourceBundle::GetSharedInstance();
-
-  g_active_images.image_l = rb.GetImageSkiaNamed(IDR_TAB_ACTIVE_LEFT);
-  g_active_images.image_c = rb.GetImageSkiaNamed(IDR_TAB_ACTIVE_CENTER);
-  g_active_images.image_r = rb.GetImageSkiaNamed(IDR_TAB_ACTIVE_RIGHT);
-  g_active_images.l_width = g_active_images.image_l->width();
-  g_active_images.r_width = g_active_images.image_r->width();
-
-  g_inactive_images.image_l = rb.GetImageSkiaNamed(IDR_TAB_INACTIVE_LEFT);
-  g_inactive_images.image_c = rb.GetImageSkiaNamed(IDR_TAB_INACTIVE_CENTER);
-  g_inactive_images.image_r = rb.GetImageSkiaNamed(IDR_TAB_INACTIVE_RIGHT);
-  g_inactive_images.l_width = g_inactive_images.image_l->width();
-  g_inactive_images.r_width = g_inactive_images.image_r->width();
-
-  g_mask_images.image_l = rb.GetImageSkiaNamed(IDR_TAB_ALPHA_LEFT);
-  g_mask_images.image_r = rb.GetImageSkiaNamed(IDR_TAB_ALPHA_RIGHT);
-  g_mask_images.l_width = g_mask_images.image_l->width();
-  g_mask_images.r_width = g_mask_images.image_r->width();
-}
-
 // Performs a one-time initialization of static resources such as tab images.
 void InitTabResources() {
   static bool initialized = false;
   if (initialized)
     return;
 
   initialized = true;
   g_image_cache = new ImageCache();
-
-  // Load the tab images once now, and maybe again later if the theme changes.
-  LoadTabImages();
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // Drawing and utility functions
 
 // Returns the width of the tab endcap at scale 1.  More precisely, this is the
 // width of the curve making up either the outer or inner edge of the stroke;
 // since these two curves are horizontally offset by 1 px (regardless of scale),
 // the total width of the endcap from tab outer edge to the inside end of the
 // stroke inner edge is (GetUnscaledEndcapWidth() * scale) + 1.
@@ skipping 61 matching lines @@
 
 // Returns a path corresponding to the tab's outer border for a given tab |size|
 // and |scale|.  If |unscale_at_end| is true, this path will be normalized to a
 // 1x scale by scaling by 1/scale before returning.  If |extend_to_top| is true,
 // the path is extended vertically to the top of the tab bounds.  The caller
 // uses this for Fitts' Law purposes in maximized/fullscreen mode.
 gfx::Path GetBorderPath(float scale,
                         bool unscale_at_end,
                         bool extend_to_top,
                         const gfx::Size& size) {
+  const float top = scale - 1;
+  const float right = size.width() * scale;
+  const float bottom = size.height() * scale;
+  const float unscaled_endcap_width = GetUnscaledEndcapWidth();
+
   gfx::Path path;
-  if (ui::MaterialDesignController::IsModeMaterial()) {
-    const float top = scale - 1;
-    const float right = size.width() * scale;
-    const float bottom = size.height() * scale;
-    const float unscaled_endcap_width = GetUnscaledEndcapWidth();
+  path.moveTo(0, bottom);
+  path.rLineTo(0, -1);
+  path.rCubicTo(0.75 * scale, 0, 1.625 * scale, -0.5 * scale, 2 * scale,
+                -1.5 * scale);
+  path.lineTo((unscaled_endcap_width - 2) * scale, top + 1.5 * scale);
+  if (extend_to_top) {
+    // Create the vertical extension by extending the side diagonals until
+    // they reach the top of the bounds.
+    const float dy = 2.5 * scale - 1;
+    const float dx = Tab::GetInverseDiagonalSlope() * dy;
+    path.rLineTo(dx, -dy);
+    path.lineTo(right - (unscaled_endcap_width - 2) * scale - dx, 0);
+    path.rLineTo(dx, dy);
+  } else {
+    path.rCubicTo(0.375 * scale, -scale, 1.25 * scale, -1.5 * scale, 2 * scale,
+                  -1.5 * scale);
+    path.lineTo(right - unscaled_endcap_width * scale, top);
+    path.rCubicTo(0.75 * scale, 0, 1.625 * scale, 0.5 * scale, 2 * scale,
+                  1.5 * scale);
+  }
+  path.lineTo(right - 2 * scale, bottom - 1 - 1.5 * scale);
+  path.rCubicTo(0.375 * scale, scale, 1.25 * scale, 1.5 * scale, 2 * scale,
+                1.5 * scale);
+  path.rLineTo(0, 1);
+  path.close();
 
-    path.moveTo(0, bottom);
-    path.rLineTo(0, -1);
-    path.rCubicTo(0.75 * scale, 0, 1.625 * scale, -0.5 * scale, 2 * scale,
-                  -1.5 * scale);
-    path.lineTo((unscaled_endcap_width - 2) * scale, top + 1.5 * scale);
-    if (extend_to_top) {
-      // Create the vertical extension by extending the side diagonals until
-      // they reach the top of the bounds.
-      const float dy = 2.5 * scale - 1;
-      const float dx = Tab::GetInverseDiagonalSlope() * dy;
-      path.rLineTo(dx, -dy);
-      path.lineTo(right - (unscaled_endcap_width - 2) * scale - dx, 0);
-      path.rLineTo(dx, dy);
-    } else {
-      path.rCubicTo(0.375 * scale, -scale, 1.25 * scale, -1.5 * scale,
-                    2 * scale, -1.5 * scale);
-      path.lineTo(right - unscaled_endcap_width * scale, top);
-      path.rCubicTo(0.75 * scale, 0, 1.625 * scale, 0.5 * scale, 2 * scale,
-                    1.5 * scale);
-    }
-    path.lineTo(right - 2 * scale, bottom - 1 - 1.5 * scale);
-    path.rCubicTo(0.375 * scale, scale, 1.25 * scale, 1.5 * scale, 2 * scale,
-                  1.5 * scale);
-    path.rLineTo(0, 1);
-    path.close();
-
-    if (unscale_at_end && (scale != 1))
-      path.transform(SkMatrix::MakeScale(1.f / scale));
-  } else {
-    // Hit mask constants.
-    const SkScalar kTabCapWidth = 15;
-    const SkScalar kTabTopCurveWidth = 4;
-    const SkScalar kTabBottomCurveWidth = 3;
-#if defined(OS_MACOSX)
-    // Mac's Cocoa UI doesn't have shadows.
-    const SkScalar kTabInset = 0;
-#elif defined(TOOLKIT_VIEWS)
-    // The views browser UI has shadows in the left, right and top parts of the
-    // tab.
-    const SkScalar kTabInset = 6;
-#endif
-
-    SkScalar left = kTabInset;
-    SkScalar top = SkIntToScalar(0);
-    SkScalar right = SkIntToScalar(size.width()) - kTabInset;
-    SkScalar bottom = SkIntToScalar(size.height());
-
-    // Start in the lower-left corner.
-    path.moveTo(left, bottom);
-
-    // Left end cap.
-    path.lineTo(left + kTabBottomCurveWidth, bottom - kTabBottomCurveWidth);
-    path.lineTo(left + kTabCapWidth - kTabTopCurveWidth,
-                top + kTabTopCurveWidth);
-    path.lineTo(left + kTabCapWidth, top);
-
-    // Connect to the right cap.
-    path.lineTo(right - kTabCapWidth, top);
-
-    // Right end cap.
-    path.lineTo(right - kTabCapWidth + kTabTopCurveWidth,
-                top + kTabTopCurveWidth);
-    path.lineTo(right - kTabBottomCurveWidth, bottom - kTabBottomCurveWidth);
-    path.lineTo(right, bottom);
-
-    // Close out the path.
-    path.lineTo(left, bottom);
-    path.close();
-
-    // Unscaling is not necessary since we never scaled up to begin with.
-  }
+  if (unscale_at_end && (scale != 1))
+    path.transform(SkMatrix::MakeScale(1.f / scale));
 
   return path;
 }
 
-void PaintTabFill(gfx::Canvas* canvas,
-                  const gfx::ImageSkia& fill_image,
-                  gfx::Rect rect,
-                  bool is_active) {
-  const gfx::Insets tab_insets(GetLayoutInsets(TAB));
-  // If this isn't the foreground tab, don't draw over the toolbar, but do
-  // include the 1 px divider stroke at the bottom.
-  const int toolbar_overlap = is_active ? 0 : (tab_insets.bottom() - 1);
-
-  // Draw left edge.
-  gfx::ImageSkia tab_l = gfx::ImageSkiaOperations::CreateTiledImage(
-      fill_image, rect.x(), rect.y(), g_mask_images.l_width, rect.height());
-  gfx::ImageSkia theme_l = gfx::ImageSkiaOperations::CreateMaskedImage(
-      tab_l, *g_mask_images.image_l);
-  canvas->DrawImageInt(
-      theme_l, 0, 0, theme_l.width(), theme_l.height() - toolbar_overlap, 0, 0,
-      theme_l.width(), theme_l.height() - toolbar_overlap, false);
-
-  // Draw right edge.
-  gfx::ImageSkia tab_r = gfx::ImageSkiaOperations::CreateTiledImage(
-      fill_image, rect.right() - g_mask_images.r_width, rect.y(),
-      g_mask_images.r_width, rect.height());
-  gfx::ImageSkia theme_r = gfx::ImageSkiaOperations::CreateMaskedImage(
-      tab_r, *g_mask_images.image_r);
-  canvas->DrawImageInt(theme_r, 0, 0, theme_r.width(),
-                       theme_r.height() - toolbar_overlap,
-                       rect.width() - theme_r.width(), 0, theme_r.width(),
-                       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());
-}
-
 }  // namespace
 
 ////////////////////////////////////////////////////////////////////////////////
 // FaviconCrashAnimation
 //
 //  A custom animation subclass to manage the favicon crash animation.
 class Tab::FaviconCrashAnimation : public gfx::LinearAnimation,
                                    public gfx::AnimationDelegate {
  public:
   explicit FaviconCrashAnimation(Tab* target)
@@ skipping 200 matching lines @@
 
 // static
 const char Tab::kViewClassName[] = "Tab";
 
 Tab::Tab(TabController* controller, gfx::AnimationContainer* container)
     : controller_(controller),
       closing_(false),
       dragging_(false),
       detached_(false),
       favicon_hiding_offset_(0),
-      immersive_loading_step_(0),
       should_display_crashed_favicon_(false),
       pulse_animation_(new gfx::ThrobAnimation(this)),
       crash_icon_animation_(new FaviconCrashAnimation(this)),
       animation_container_(container),
       throbber_(nullptr),
       alert_indicator_button_(nullptr),
       close_button_(nullptr),
       title_(new views::Label()),
       tab_activated_with_last_tap_down_(false),
       hover_controller_(this),
@@ skipping 190 matching lines @@
   return kTouchWidth;
 }
 
 // static
 int Tab::GetPinnedWidth() {
   return GetMinimumInactiveSize().width() +
          GetLayoutConstant(TAB_PINNED_CONTENT_WIDTH);
 }
 
 // static
-int Tab::GetImmersiveHeight() {
-  return kImmersiveTabHeight;
-}
-
-// static
 float Tab::GetInverseDiagonalSlope() {
   // This is computed from the border path as follows:
   // * The unscaled endcap width is enough for the whole stroke outer curve,
   //   i.e. the side diagonal plus the curves on both its ends.
   // * The bottom and top curve are each (2 * scale) px wide, so the diagonal is
   //   (unscaled endcap width - 2 - 2) * scale px wide.
   // * The bottom and top curve are each 1.5 px high.  Additionally, there is an
   //   extra 1 px below the bottom curve and (scale - 1) px above the top curve,
   //   so the diagonal is ((height - 1.5 - 1.5) * scale - 1 - (scale - 1)) px
   //   high.
@@ skipping 52 matching lines @@
   if (!closing())
     controller_->ShowContextMenuForTab(this, point, source_type);
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // Tab, views::MaskedTargeterDelegate overrides:
 
 bool Tab::GetHitTestMask(gfx::Path* mask) const {
   // 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.
+  // edge of the screen to select a tab.
   const views::Widget* widget = GetWidget();
   *mask = GetBorderPath(
       GetWidget()->GetCompositor()->device_scale_factor(), true,
       widget && (widget->IsMaximized() || widget->IsFullscreen()), size());
   return true;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // Tab, views::View overrides:
 
@@ skipping 10 matching lines @@
   // only happen during animations).
   if (width() < GetMinimumInactiveSize().width() && !data().pinned)
     return;
 
   gfx::Path clip;
   if (!controller_->ShouldPaintTab(
           this, base::Bind(&GetBorderPath, canvas->image_scale(), true, false),
           &clip))
     return;
 
-  if (controller_->IsImmersiveStyle())
-    PaintImmersiveTab(canvas);
-  else
-    PaintTab(canvas, clip);
+  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 64 matching lines @@
     }
     // The Label will automatically center the font's cap height within the
     // provided vertical space.
     title_->SetBoundsRect(
         gfx::Rect(title_left, lb.y(), std::max(title_width, 0), lb.height()));
   }
   title_->SetVisible(show_title);
 }
 
 void Tab::OnThemeChanged() {
-  LoadTabImages();
   OnButtonColorMaybeChanged();
   favicon_ = gfx::ImageSkia();
 }
 
 const char* Tab::GetClassName() const {
   return kViewClassName;
 }
 
 bool Tab::GetTooltipText(const gfx::Point& p, base::string16* tooltip) const {
   // Note: Anything that affects the tooltip text should be accounted for when
@@ skipping 207 matching lines @@
       PaintTabBackgroundUsingFillId(canvas, canvas, true, kActiveTabFillId,
                                     has_custom_image, y_offset);
       canvas->Restore();
     }
   }
 
   if (showing_icon_)
     PaintIcon(canvas);
 }
 
-void Tab::PaintImmersiveTab(gfx::Canvas* canvas) {
-  // Use transparency for the draw-attention animation.
-  int alpha = 255;
-  if (pulse_animation_->is_animating() && !data().pinned) {
-    alpha = pulse_animation_->CurrentValueBetween(
-        255, gfx::ToRoundedInt(255 * kImmersiveTabMinThrobOpacity));
-  }
-
-  // Draw a gray rectangle to represent the tab. This works for pinned tabs as
-  // well as regular ones. The active tab has a brigher bar.
-  SkColor color =
-      IsActive() ? kImmersiveActiveTabColor : kImmersiveInactiveTabColor;
-  gfx::Rect bar_rect = GetImmersiveBarRect();
-  canvas->FillRect(bar_rect, SkColorSetA(color, alpha));
-
-  // Paint network activity indicator.
-  // TODO(jamescook): Replace this placeholder animation with a real one.
-  // For now, let's go with a Cylon eye effect, but in blue.
-  if (data().network_state != TabRendererData::NETWORK_STATE_NONE) {
-    const SkColor kEyeColor = SkColorSetARGB(alpha, 71, 138, 217);
-    int eye_width = bar_rect.width() / 3;
-    int eye_offset = bar_rect.width() * immersive_loading_step_ /
-        kImmersiveLoadingStepCount;
-    if (eye_offset + eye_width < bar_rect.width()) {
-      // Draw a single indicator strip because it fits inside |bar_rect|.
-      gfx::Rect eye_rect(
-          bar_rect.x() + eye_offset, 0, eye_width, kImmersiveBarHeight);
-      canvas->FillRect(eye_rect, kEyeColor);
-    } else {
-      // Draw two indicators to simulate the eye "wrapping around" to the left
-      // side. The first part fills the remainder of the bar.
-      int right_eye_width = bar_rect.width() - eye_offset;
-      gfx::Rect right_eye_rect(
-          bar_rect.x() + eye_offset, 0, right_eye_width, kImmersiveBarHeight);
-      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,
                                      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) ? 0 : 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);
     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 bool use_fill_and_stroke_images = controller_->MaySetClip();
 
   const ImageCacheEntryMetadata metadata(
-      fill_id, tp->GetColor(ThemeProperties::COLOR_BACKGROUND_TAB),
+      tp->GetColor(ThemeProperties::COLOR_BACKGROUND_TAB),
       controller_->GetToolbarTopSeparatorColor(), use_fill_and_stroke_images,
       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);
     if (use_fill_and_stroke_images) {
       gfx::Canvas tmp_fill_canvas(size(), canvas->image_scale(), false);
       PaintTabBackgroundUsingFillId(&tmp_fill_canvas, &tmp_canvas, false,
@@ skipping 21 matching lines @@
   }
   canvas->DrawImageInt(it->stroke_image, 0, 0);
 }
 
 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();
+  gfx::Path fill;
+  SkPaint paint;
+  paint.setAntiAlias(true);
 
-  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());
+  // Draw the fill.
+  {
+    gfx::ScopedCanvas scoped_canvas(fill_canvas);
+    const float scale = fill_canvas->UndoDeviceScaleFactor();
+    const ui::ThemeProvider* tp = GetThemeProvider();
+    const SkColor toolbar_color = tp->GetColor(ThemeProperties::COLOR_TOOLBAR);
 
-  if (ui::MaterialDesignController::IsModeMaterial()) {
-    gfx::Path fill;
-    SkPaint paint;
-    paint.setAntiAlias(true);
+    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(*tp->GetImageSkiaNamed(fill_id),
+                                  GetMirroredX() + background_offset_.x(),
+                                  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);
+      }
 
-    // Draw the fill.
-    {
-      gfx::ScopedCanvas scoped_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);
-        }
+      if (!is_active && hover_controller_.ShouldDraw()) {
+        SkPoint hover_location(
+            gfx::PointToSkPoint(hover_controller_.location()));
+        hover_location.scale(SkFloatToScalar(scale));
+        const SkScalar kMinHoverRadius = 16;
+        const SkScalar radius =
+            std::max(SkFloatToScalar(width() / 4.f), kMinHoverRadius);
+        DrawHighlight(fill_canvas, hover_location, radius * scale,
+                      SkColorSetA(toolbar_color, hover_controller_.GetAlpha()));
       }
     }
+  }
 
-    // Draw the stroke.
-    {
-      gfx::ScopedCanvas scoped_canvas(stroke_canvas);
-      const float scale = stroke_canvas->UndoDeviceScaleFactor();
+  // Draw the stroke.
+  {
+    gfx::ScopedCanvas scoped_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);
+    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));
     }
-  } else {
-    gfx::Canvas* canvas = stroke_canvas;
-    gfx::Rect rect(gfx::Point(x_offset, y_offset), size());
-    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, rect, is_active);
-      gfx::ImageSkia background_image(background_canvas.ExtractImageRep());
-      canvas->DrawImageInt(background_image, 0, 0);
-
-      gfx::Canvas hover_canvas(size(), canvas->image_scale(), false);
-      DrawHighlight(&hover_canvas, 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, *fill_image, rect, is_active);
-    }
-
-    // Now draw the stroke, highlights, and shadows around the tab edge.
-    TabImages* stroke_images =
-        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,
-        width() - stroke_images->l_width - stroke_images->r_width, height());
-    canvas->DrawImageInt(*stroke_images->image_r,
-                         width() - stroke_images->r_width, 0);
+    paint.setColor(controller_->GetToolbarTopSeparatorColor());
+    stroke_canvas->DrawPath(stroke, paint);
   }
 }
 
 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.
@@ skipping 65 matching lines @@
       !should_display_crashed_favicon_) {
     PaintPinnedTabTitleChangedIndicatorAndIcon(canvas, bounds);
   } else if (!favicon_.isNull()) {
     canvas->DrawImageInt(favicon_, 0, 0, bounds.width(), bounds.height(),
                          bounds.x(), bounds.y(), bounds.width(),
                          bounds.height(), false);
   }
 }
 
 void Tab::AdvanceLoadingAnimation() {
-  const TabRendererData::NetworkState state = data().network_state;
-  if (controller_->IsImmersiveStyle()) {
-    throbber_->SetVisible(false);
-    if (state == TabRendererData::NETWORK_STATE_WAITING) {
-      // Waiting steps backwards.
-      immersive_loading_step_ =
-          (immersive_loading_step_ - 1 + kImmersiveLoadingStepCount) %
-          kImmersiveLoadingStepCount;
-    } else if (state == TabRendererData::NETWORK_STATE_LOADING) {
-      immersive_loading_step_ =
-          (immersive_loading_step_ + 1) % kImmersiveLoadingStepCount;
-    } else {
-      immersive_loading_step_ = 0;
-    }
-
-    SchedulePaintInRect(GetImmersiveBarRect());
-    return;
-  }
-
-  if (state == TabRendererData::NETWORK_STATE_NONE) {
+  if (data().network_state == TabRendererData::NETWORK_STATE_NONE) {
     throbber_->ResetStartTimes();
     throbber_->SetVisible(false);
     ScheduleIconPaint();
     return;
   }
 
   // Since the throbber can animate for a long time, paint to a separate layer
   // when possible to reduce repaint overhead.
   const bool paint_to_layer = controller_->CanPaintThrobberToLayer();
   if (paint_to_layer != !!throbber_->layer()) {
@@ skipping 113 matching lines @@
   gfx::Rect bounds = favicon_bounds_;
   if (bounds.IsEmpty())
     return;
 
   // Extends the area to the bottom when the crash animation is in progress.
   if (crash_icon_animation_->is_animating())
     bounds.set_height(height() - bounds.y());
   bounds.set_x(GetMirroredXForRect(bounds));
   SchedulePaintInRect(bounds);
 }
-
-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);
-}