Remove some more !IsModeMaterial code.

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 1125 matching lines @@
   if (data().blocked == old.blocked)
     return;
 
   if (data().blocked)
     StartPulse();
   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 kActiveTabFillId =
+      GetThemeProvider()->HasCustomImage(IDR_THEME_TOOLBAR) ? IDR_THEME_TOOLBAR
+                                                            : 0;
   const int y_offset = -GetLayoutInsets(TAB).top();
   if (IsActive()) {
     PaintTabBackgroundUsingFillId(canvas, canvas, true, kActiveTabFillId,
-                                  has_custom_image, y_offset);
+                                  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,
-                                    has_custom_image, y_offset);
+                                    y_offset);
       canvas->Restore();
     }
   }
 
   if (showing_icon_)
     PaintIcon(canvas);
 }
 
 void Tab::PaintImmersiveTab(gfx::Canvas* canvas) {
   // Use transparency for the draw-attention animation.
@@ skipping 36 matching lines @@
           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);
+  if (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 int y_offset =
+        tp->HasCustomImage(fill_id) ? 0 : background_offset_.y();
+    PaintTabBackgroundUsingFillId(canvas, canvas, false, fill_id, y_offset);
+    return;
+  }
+  if (hover_controller_.ShouldDraw()) {
+    PaintTabBackgroundUsingFillId(canvas, canvas, false, 0, 0);
     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();
 
   const ImageCacheEntryMetadata metadata(
       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,
-                                    fill_id, false, y_offset);
+      PaintTabBackgroundUsingFillId(&tmp_fill_canvas, &tmp_canvas, false, 0, 0);
       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);
+      PaintTabBackgroundUsingFillId(&tmp_canvas, &tmp_canvas, false, 0, 0);
       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();
   }
 
   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,
                                         bool is_active,
                                         int fill_id,
-                                        bool has_custom_image,
                                         int y_offset) {
   gfx::Path fill;
   SkPaint paint;
   paint.setAntiAlias(true);
 
   // 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);
 
     fill = GetFillPath(scale, size());
     {
       gfx::ScopedCanvas clip_scoper(fill_canvas);
       fill_canvas->ClipPath(fill, true);
-      if (has_custom_image) {
+      if (fill_id) {
         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(
@@ skipping 267 matching lines @@
   SchedulePaintInRect(bounds);
 }
 
 gfx::Rect Tab::GetImmersiveBarRect() const {
   // The main bar is as wide as the normal tab's horizontal top line.
   gfx::Rect contents = GetContentsBounds();
   contents.set_y(0);
   contents.set_height(kImmersiveBarHeight);
   return contents;
 }