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.

[Peter Kasting, 2016/10/21 21:07:50]

Nit: This comment is slightly confusing now that you broke the hover handling
into a separate block below.

Honestly, I'd probably just leave this structured as it was before (i.e. handle
hover in this block as well).  No changes to the current body of the block
should be needed (there's no need to detect hover and force the fill_id to zero
or anything).  And the resulting code winds up being shorter too.

[Evan Stade, 2016/10/21 22:11:12]

actually, there would be a need for 

  ..., has_custom_image ? fill_id : 0, ...

and since both fill_id and y_offset both aren't needed if !has_custom_image, I
thought it was clearer to separate.

[Peter Kasting, 2016/10/22 00:14:44]

Ah, you're right.  Man, I thought through this like three times and still didn't
see that that would, in fact, be needed.

Maybe just delete the blank line between these two chunks, then, since the
comment above describes both?

[Evan Stade, 2016/10/24 13:01:20]

incidentally, already done in latest patchset

-  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 != 0) {

[Peter Kasting, 2016/10/21 21:07:51]

Nit: To avoid the else reading like a double-negative, I would either write this
as "if (fill_id)", or else flip the conditional and reverse the arms.

[Evan Stade, 2016/10/21 22:11:12]

Done.

         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;
 }