Proper rendering of stacked tabs for MD.

chrome/browser/ui/views/tabs/tab_strip.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_strip.h"
 
 #include <stddef.h>
 
 #include <algorithm>
 #include <iterator>
@@ skipping 91 matching lines @@
 
 // See UpdateLayoutTypeFromMouseEvent() for a description of these.
 #if !defined(USE_ASH)
 const int kMouseMoveTimeMS = 200;
 const int kMouseMoveCountBeforeConsiderReal = 3;
 #endif
 
 // Amount of time we delay before resizing after a close from a touch.
 const int kTouchResizeLayoutTimeMS = 2000;
 
-// Amount to adjust the clip by when the tab is stacked before the active index.
-const int kStackedTabLeftClip = 20;
-
-// Amount to adjust the clip by when the tab is stacked after the active index.
-const int kStackedTabRightClip = 20;
-
 #if defined(OS_MACOSX)
 const int kPinnedToNonPinnedOffset = 2;
 #else
 const int kPinnedToNonPinnedOffset = 3;
 #endif
 
 // Returns the offset from the top of the tabstrip at which the new tab button's
 // visible region begins.
 int GetNewTabButtonTopOffset() {
   // The vertical distance between the bottom of the new tab button and the
@@ skipping 1030 matching lines @@
 }
 
 bool TabStrip::ShouldHideCloseButtonForInactiveTabs() {
   if (!touch_layout_)
     return false;
 
   return !base::CommandLine::ForCurrentProcess()->HasSwitch(
       switches::kDisableHideInactiveStackedTabCloseButtons);
 }
 
+bool TabStrip::MaySetClip() {
+  // Only touch layout needs to restrict the clip.
+  return touch_layout_ || IsStackingDraggedTabs();
+}
+
 void TabStrip::SelectTab(Tab* tab) {
   int model_index = GetModelIndexOfTab(tab);
   if (IsValidModelIndex(model_index))
     controller_->SelectTab(model_index);
 }
 
 void TabStrip::ExtendSelectionTo(Tab* tab) {
   int model_index = GetModelIndexOfTab(tab);
   if (IsValidModelIndex(model_index))
     controller_->ExtendSelectionTo(model_index);
@@ skipping 161 matching lines @@
     view = view->parent();
 
   return view && view->id() == VIEW_ID_TAB ? static_cast<Tab*>(view) : NULL;
 }
 
 void TabStrip::OnMouseEventInTab(views::View* source,
                                  const ui::MouseEvent& event) {
   UpdateStackedLayoutFromMouseEvent(source, event);
 }
 
-bool TabStrip::ShouldPaintTab(const Tab* tab, gfx::Rect* clip) {
-  // Only touch layout needs to restrict the clip.
-  if (!touch_layout_ && !IsStackingDraggedTabs())
+bool TabStrip::ShouldPaintTab(
+    const Tab* tab,
+    const base::Callback<gfx::Path(const gfx::Size&)>& border_callback,
+    gfx::Path* clip) {
+  if (!MaySetClip())
     return true;
 
   int index = GetModelIndexOfTab(tab);
   if (index == -1)
     return true;  // Tab is closing, paint it all.
 
   int active_index = IsStackingDraggedTabs() ?
       controller_->GetActiveIndex() : touch_layout_->active_index();
   if (active_index == tab_count())
     active_index--;
 
   const int current_x = tab_at(index)->x();
   if (index < active_index) {
     const int next_x = tab_at(index + 1)->x();
     if (current_x == next_x)
       return false;
 
     if (current_x > next_x)
       return true;  // Can happen during dragging.
 
-    clip->SetRect(
-        0, 0, next_x - current_x + kStackedTabLeftClip,
-        tab_at(index)->height());
+    *clip = border_callback.Run(tab_at(index + 1)->size());
+    clip->offset(SkIntToScalar(next_x - current_x), 0);
   } else if (index > active_index && index > 0) {
     const gfx::Rect& previous_bounds(tab_at(index - 1)->bounds());
     const int previous_x = previous_bounds.x();
     if (current_x == previous_x)
       return false;
 
     if (current_x < previous_x)
       return true;  // Can happen during dragging.
 
     if (previous_bounds.right() - GetLayoutConstant(TABSTRIP_TAB_OVERLAP) !=
         current_x) {
-      int x = previous_bounds.right() - current_x - kStackedTabRightClip;
-      const gfx::Rect& tab_bounds(tab_at(index)->bounds());
-      clip->SetRect(x, 0, tab_bounds.width() - x, tab_bounds.height());
+      *clip = border_callback.Run(tab_at(index - 1)->size());
+      clip->offset(SkIntToScalar(previous_x - current_x), 0);
     }
   }
   return true;
 }
 
 bool TabStrip::CanPaintThrobberToLayer() const {
   // Disable layer-painting of throbbers if dragging, if any tab animation is in
   // progress, or if stacked tabs are enabled. Also disable in fullscreen: when
   // "immersive" the tab strip could be sliding in or out while transitioning to
   // or away from |immersive_style_| and, for other modes, there's no tab strip.
@@ skipping 1488 matching lines @@
           ConvertPointToViewAndGetEventHandler(this, newtab_button_, point);
       if (view)
         return view;
     }
     Tab* tab = FindTabForEvent(point);
     if (tab)
       return ConvertPointToViewAndGetEventHandler(this, tab, point);
   }
   return this;
 }