Miscellaneous cleanup.

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 <limits>
 
 #include "base/command_line.h"
 #include "base/debug/alias.h"
@@ skipping 43 matching lines @@
 #include "ui/views/window/non_client_view.h"
 
 #if defined(USE_AURA)
 #include "ui/aura/env.h"
 #endif
 
 using base::UserMetricsAction;
 
 namespace {
 
-// Height of the shadow at the top of the tab image assets.
-const int kDropShadowHeight = 4;
-
 // How long the pulse throb takes.
 const int kPulseDurationMs = 200;
 
 // Width of touch tabs.
 const int kTouchWidth = 120;
 
-const int kToolbarOverlap = 1;
 const int kExtraLeftPaddingToBalanceCloseButtonPadding = 2;
 const int kAfterTitleSpacing = 4;
 
 // When a non-pinned tab becomes a pinned tab the width of the tab animates. If
 // the width of a pinned tab is at least kPinnedTabExtraWidthToRenderAsNormal
 // larger than the desired pinned tab width then the tab is rendered as a normal
 // tab. This is done to avoid having the title immediately disappear when
 // transitioning a tab from normal to pinned tab.
 const int kPinnedTabExtraWidthToRenderAsNormal = 30;
 
@@ skipping 47 matching lines @@
 // 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";
 const int kTabCloseButtonSize = 16;
 
-void DrawIconAtLocation(gfx::Canvas* canvas,
-                        const gfx::ImageSkia& image,
-                        int image_offset,
-                        int dst_x,
-                        int dst_y,
-                        int icon_width,
-                        int icon_height,
-                        bool filter,
-                        const SkPaint& paint) {
-  // NOTE: the clipping is a work around for 69528, it shouldn't be necessary.
-  canvas->Save();
-  canvas->ClipRect(gfx::Rect(dst_x, dst_y, icon_width, icon_height));
-  canvas->DrawImageInt(image,
-                       image_offset, 0, icon_width, icon_height,
-                       dst_x, dst_y, icon_width, icon_height,
-                       filter, paint);
-  canvas->Restore();
-}
-
-// Draws the icon image at the center of |bounds|.
-void DrawIconCenter(gfx::Canvas* canvas,
-                    const gfx::ImageSkia& image,
-                    int image_offset,
-                    int icon_width,
-                    int icon_height,
-                    const gfx::Rect& bounds,
-                    bool filter,
-                    const SkPaint& paint) {
-  // Center the image within bounds.
-  int dst_x = bounds.x() - (icon_width - bounds.width()) / 2;
-  int dst_y = bounds.y() - (icon_height - bounds.height()) / 2;
-  DrawIconAtLocation(canvas, image, image_offset, dst_x, dst_y, icon_width,
-                     icon_height, filter, paint);
-}
-
 chrome::HostDesktopType GetHostDesktopType(views::View* view) {
   // Widget is NULL when tabs are detached.
   views::Widget* widget = view->GetWidget();
   return chrome::GetHostDesktopTypeForNativeView(
       widget ? widget->GetNativeView() : NULL);
 }
 
 // Stop()s |animation| and then deletes it. We do this rather than just deleting
 // so that the delegate is notified before the destruction.
 void StopAndDeleteAnimation(scoped_ptr<gfx::Animation> animation) {
@@ skipping 14 matching lines @@
       : gfx::LinearAnimation(1000, 25, this),
         target_(target) {
   }
   ~FaviconCrashAnimation() override {}
 
   // gfx::Animation overrides:
   void AnimateToState(double state) override {
     const double kHidingOffset = 27;
 
     if (state < .5) {
+      // Animate the normal icon down.
       target_->SetFaviconHidingOffset(
           static_cast<int>(floor(kHidingOffset * 2.0 * state)));
     } else {
+      // Animate the crashed icon up.
       target_->DisplayCrashedFavicon();
       target_->SetFaviconHidingOffset(
           static_cast<int>(
               floor(kHidingOffset - ((state - .5) * 2.0 * kHidingOffset))));
     }
   }
 
   // gfx::AnimationDelegate overrides:
   void AnimationCanceled(const gfx::Animation* animation) override {
     target_->SetFaviconHidingOffset(0);
@@ skipping 488 matching lines @@
 ////////////////////////////////////////////////////////////////////////////////
 // Tab, views::MaskedTargeterDelegate overrides:
 
 bool Tab::GetHitTestMask(gfx::Path* mask) const {
   DCHECK(mask);
 
   // 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();
-  GetHitTestMaskHelper(
-      widget && (widget->IsMaximized() || widget->IsFullscreen()), mask);
+  const bool extend_to_top =
+      widget && (widget->IsMaximized() || widget->IsFullscreen());
+
+  // 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;
+  const SkScalar kTabTop = 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;
+  const SkScalar kTabTop = 2;
+#endif
+
+  SkScalar left = kTabInset;
+  SkScalar top = kTabTop;
+  SkScalar right = SkIntToScalar(width()) - kTabInset;
+  SkScalar bottom = SkIntToScalar(height());
+
+  // Start in the lower-left corner.
+  mask->moveTo(left, bottom);
+
+  // Left end cap.
+  mask->lineTo(left + kTabBottomCurveWidth, bottom - kTabBottomCurveWidth);
+  mask->lineTo(left + kTabCapWidth - kTabTopCurveWidth,
+               top + kTabTopCurveWidth);
+  mask->lineTo(left + kTabCapWidth, top);
+
+  // Extend over the top shadow area if we have one and the caller wants it.
+  if (kTabTop > 0 && extend_to_top) {
+    mask->lineTo(left + kTabCapWidth, 0);
+    mask->lineTo(right - kTabCapWidth, 0);
+  }
+
+  // Connect to the right cap.
+  mask->lineTo(right - kTabCapWidth, top);
+
+  // Right end cap.
+  mask->lineTo(right - kTabCapWidth + kTabTopCurveWidth,
+               top + kTabTopCurveWidth);
+  mask->lineTo(right - kTabBottomCurveWidth, bottom - kTabBottomCurveWidth);
+  mask->lineTo(right, bottom);
+
+  // Close out the path.
+  mask->lineTo(left, bottom);
+  mask->close();
 
   // 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)))
@@ skipping 31 matching lines @@
   if (controller_->IsImmersiveStyle())
     PaintImmersiveTab(canvas);
   else
     PaintTab(canvas);
 
   if (!clip.IsEmpty())
     canvas->Restore();
 }
 
 void Tab::Layout() {
-  gfx::Rect lb = GetContentsBounds();
+  gfx::Rect lb = GetInteriorBounds();
   if (lb.IsEmpty())
     return;
 
-  lb.Inset(GetLayoutInsets(TAB));
   showing_icon_ = ShouldShowIcon();
   // See comments in IconCapacity().
   const int extra_padding =
       (controller_->ShouldHideCloseButtonForInactiveTabs() ||
        (IconCapacity() < 3)) ? 0 : kExtraLeftPaddingToBalanceCloseButtonPadding;
   const int start = lb.x() + extra_padding;
   favicon_bounds_.SetRect(start, lb.y(), 0, 0);
   if (showing_icon_) {
     favicon_bounds_.set_size(gfx::Size(gfx::kFaviconSize, gfx::kFaviconSize));
     favicon_bounds_.set_y(lb.y() + (lb.height() - gfx::kFaviconSize + 1) / 2);
@@ skipping 49 matching lines @@
         (favicon_bounds_.right() + title_spacing) : start;
     int title_width = lb.right() - title_left;
     if (showing_media_indicator_) {
       title_width =
           media_indicator_button_->x() - kAfterTitleSpacing - title_left;
     } else if (close_button_->visible()) {
       // Allow the title to overlay the close button's empty border padding.
       title_width = close_button_->x() + close_button_->GetInsets().left() -
           kAfterTitleSpacing - title_left;
     }
-    gfx::Rect rect(title_left, lb.y(), std::max(title_width, 0), lb.height());
-    const int title_height = title_->GetPreferredSize().height();
-    if (title_height > rect.height()) {
-      rect.set_y(lb.y() - (title_height - rect.height()) / 2);
-      rect.set_height(title_height);
-    }
-    title_->SetBoundsRect(rect);
+    // 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();
 }
 
 const char* Tab::GetClassName() const {
@@ skipping 376 matching lines @@
   // image is a composited foreground + frame image.
   int bg_offset_y = GetThemeProvider()->HasCustomImage(tab_id) ?
       0 : background_offset_.y();
 
   // We need a gfx::Canvas object to be able to extract the image from.
   // We draw everything to this canvas and then output it to the canvas
   // parameter in addition to using it to mask the hover glow if needed.
   gfx::Canvas background_canvas(size(), canvas->image_scale(), false);
 
   // Draw left edge.  Don't draw over the toolbar, as we're not the foreground
-  // tab.
+  // tab, but do include the 1 px divider stroke at the bottom.
+  const gfx::Insets tab_insets(GetLayoutInsets(TAB));
+  const int toolbar_overlap = tab_insets.bottom() - 1;
   gfx::ImageSkia tab_l = gfx::ImageSkiaOperations::CreateTiledImage(
       *tab_bg, offset, bg_offset_y, tab_image->l_width, height());
   gfx::ImageSkia theme_l =
       gfx::ImageSkiaOperations::CreateMaskedImage(tab_l, *alpha->image_l);
   background_canvas.DrawImageInt(theme_l,
-      0, 0, theme_l.width(), theme_l.height() - kToolbarOverlap,
-      0, 0, theme_l.width(), theme_l.height() - kToolbarOverlap,
+      0, 0, theme_l.width(), theme_l.height() - toolbar_overlap,
+      0, 0, theme_l.width(), theme_l.height() - toolbar_overlap,
       false);
 
   // Draw right edge.  Again, don't draw over the toolbar.
   gfx::ImageSkia tab_r = gfx::ImageSkiaOperations::CreateTiledImage(*tab_bg,
       offset + width() - tab_image->r_width, bg_offset_y,
       tab_image->r_width, height());
   gfx::ImageSkia theme_r =
       gfx::ImageSkiaOperations::CreateMaskedImage(tab_r, *alpha->image_r);
   background_canvas.DrawImageInt(theme_r,
-      0, 0, theme_r.width(), theme_r.height() - kToolbarOverlap,
+      0, 0, theme_r.width(), theme_r.height() - toolbar_overlap,
       width() - theme_r.width(), 0, theme_r.width(),
-      theme_r.height() - kToolbarOverlap, false);
+      theme_r.height() - toolbar_overlap, false);
 
   // Draw center.  Instead of masking out the top portion we simply skip over
-  // it by incrementing by GetDropShadowHeight(), since it's a simple
-  // rectangle. And again, don't draw over the toolbar.
-  background_canvas.TileImageInt(*tab_bg,
-     offset + tab_image->l_width,
-     bg_offset_y + kDropShadowHeight,
-     tab_image->l_width,
-     kDropShadowHeight,
+  // it by incrementing by the top padding, since it's a simple rectangle. And
+  // again, don't draw over the toolbar.
+  background_canvas.TileImageInt(
+     *tab_bg, offset + tab_image->l_width, bg_offset_y + tab_insets.top(),
+     tab_image->l_width, tab_insets.top(),
      width() - tab_image->l_width - tab_image->r_width,
-     height() - kDropShadowHeight - kToolbarOverlap);
+     height() - tab_insets.top() - toolbar_overlap);
 
   canvas->DrawImageInt(
       gfx::ImageSkia(background_canvas.ExtractImageRep()), 0, 0);
 
   if (!GetThemeProvider()->HasCustomImage(tab_id) &&
       hover_controller_.ShouldDraw()) {
     hover_controller_.Draw(canvas, gfx::ImageSkia(
         background_canvas.ExtractImageRep()));
   }
 
@@ skipping 25 matching lines @@
 
   // Draw right edge.
   gfx::ImageSkia tab_r = gfx::ImageSkiaOperations::CreateTiledImage(
       *tab_background,
       offset + width() - tab_image->r_width, 0, tab_image->r_width, height());
   gfx::ImageSkia theme_r =
       gfx::ImageSkiaOperations::CreateMaskedImage(tab_r, *alpha->image_r);
   canvas->DrawImageInt(theme_r, width() - tab_image->r_width, 0);
 
   // Draw center.  Instead of masking out the top portion we simply skip over it
-  // by incrementing by GetDropShadowHeight(), since it's a simple rectangle.
-  canvas->TileImageInt(*tab_background,
-     offset + tab_image->l_width,
-     kDropShadowHeight,
-     tab_image->l_width,
-     kDropShadowHeight,
-     width() - tab_image->l_width - tab_image->r_width,
-     height() - kDropShadowHeight);
+  // by incrementing by the top padding, since it's a simple rectangle.
+  const int top_padding = GetLayoutInsets(TAB).top();
+  canvas->TileImageInt(*tab_background, offset + tab_image->l_width,
+                       top_padding, tab_image->l_width, top_padding,
+                       width() - tab_image->l_width - tab_image->r_width,
+                       height() - top_padding);
 
   // Now draw the highlights/shadows around the tab edge.
   canvas->DrawImageInt(*tab_image->image_l, 0, 0);
   canvas->TileImageInt(*tab_image->image_c, tab_image->l_width, 0,
       width() - tab_image->l_width - tab_image->r_width, height());
   canvas->DrawImageInt(*tab_image->image_r, width() - tab_image->r_width, 0);
 }
 
 void Tab::PaintIcon(gfx::Canvas* canvas) {
   gfx::Rect bounds = favicon_bounds_;
@@ skipping 18 matching lines @@
       if (loading_start_time_ == base::TimeTicks())
         loading_start_time_ = base::TimeTicks::Now();
 
       waiting_state_.color =
           tp->GetColor(ThemeProperties::COLOR_THROBBER_WAITING);
       gfx::PaintThrobberSpinningAfterWaiting(
           canvas, bounds,
           tp->GetColor(ThemeProperties::COLOR_THROBBER_SPINNING),
           base::TimeTicks::Now() - loading_start_time_, &waiting_state_);
     }
-  } else if (should_display_crashed_favicon_) {
-    // Paint crash favicon.
-    ui::ResourceBundle& rb = ui::ResourceBundle::GetSharedInstance();
-    gfx::ImageSkia crashed_favicon(
-        *rb.GetImageSkiaNamed(IDR_CRASH_SAD_FAVICON));
-    bounds.set_y(bounds.y() + favicon_hiding_offset_);
-    DrawIconCenter(canvas, crashed_favicon, 0,
-                   crashed_favicon.width(),
-                   crashed_favicon.height(),
-                   bounds, true, SkPaint());
-  } else if (!data().favicon.isNull()) {
-    // Paint the normal favicon.
-    DrawIconCenter(canvas, data().favicon, 0,
-                   data().favicon.width(),
-                   data().favicon.height(),
-                   bounds, true, SkPaint());
+  } else {
+    const gfx::ImageSkia& favicon = should_display_crashed_favicon_ ?
+        *ui::ResourceBundle::GetSharedInstance().GetImageSkiaNamed(
+            IDR_CRASH_SAD_FAVICON) :
+        data().favicon;
+    if (!favicon.isNull()) {
+      canvas->DrawImageInt(favicon, 0, 0, bounds.width(), bounds.height(),
+                           bounds.x(), bounds.y(), bounds.width(),
+                           bounds.height(), false);
+    }
   }
 }
 
 void Tab::AdvanceLoadingAnimation(TabRendererData::NetworkState old_state,
                                   TabRendererData::NetworkState state) {
   if (state == TabRendererData::NETWORK_STATE_WAITING) {
     // Waiting steps backwards.
     immersive_loading_step_ =
         (immersive_loading_step_ - 1 + kImmersiveLoadingStepCount) %
             kImmersiveLoadingStepCount;
@@ skipping 139 matching lines @@
   if (bounds.IsEmpty())
     return;
 
   // Extends the area to the bottom when sad_favicon is animating.
   if (IsPerformingCrashAnimation())
     bounds.set_height(height() - bounds.y());
   bounds.set_x(GetMirroredXForRect(bounds));
   SchedulePaintInRect(bounds);
 }
 
-void Tab::GetHitTestMaskHelper(bool include_top_shadow, gfx::Path* path) const {
-  DCHECK(path);
-
-  // 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;
-  const SkScalar kTabTop = 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;
-  const SkScalar kTabTop = 2;
-#endif
-
-  SkScalar left = kTabInset;
-  SkScalar top = kTabTop;
-  SkScalar right = SkIntToScalar(width()) - kTabInset;
-  SkScalar bottom = SkIntToScalar(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);
-
-  // Extend over the top shadow area if we have one and the caller wants it.
-  if (kTabTop > 0 && include_top_shadow) {
-    path->lineTo(left + kTabCapWidth, 0);
-    path->lineTo(right - kTabCapWidth, 0);
-  }
-
-  // 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();
+gfx::Rect Tab::GetInteriorBounds() const {
+  gfx::Rect bounds(GetContentsBounds());
+  bounds.Inset(GetLayoutInsets(TAB));

[sky, 2015/10/09 16:31:38]

Did you consider: SetBorder(Border::CreateEmptyBorer(GetLayoutInsets(TAB)), then
getting rid of GetInteriorBounds() and using GetContentsBounds()?

+  return 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 = tab_active_.l_width - kBarPadding;
   int main_bar_right = width() - tab_active_.r_width + kBarPadding;
   return gfx::Rect(
@@ skipping 73 matching lines @@
                          const gfx::ImageSkia& image) {
   DCHECK_NE(scale_factor, ui::SCALE_FACTOR_NONE);
   ImageCacheEntry entry;
   entry.resource_id = resource_id;
   entry.scale_factor = scale_factor;
   entry.image = image;
   image_cache_->push_front(entry);
   if (image_cache_->size() > kMaxImageCacheSize)
     image_cache_->pop_back();
 }