Miscellaneous cleanup.

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"
 
 #if defined(OS_WIN)
 #include <windowsx.h>
 #endif
 
@@ skipping 57 matching lines @@
 #include "ui/gfx/win/hwnd_util.h"
 #include "ui/views/widget/monitor_win.h"
 #include "ui/views/win/hwnd_util.h"
 #endif
 
 using base::UserMetricsAction;
 using ui::DropTargetEvent;
 
 namespace {
 
-static const int kTabStripAnimationVSlop = 40;
+const int kNewTabButtonHeight = 18;
+
+const int kTabStripAnimationVSlop = 40;
+
 // Inactive tabs in a native frame are slightly transparent.
-static const uint8_t kGlassFrameInactiveTabAlpha = 200;
+const uint8_t kGlassFrameInactiveTabAlpha = 200;
 // If there are multiple tabs selected then make non-selected inactive tabs
 // even more transparent.
-static const int kGlassFrameInactiveTabAlphaMultiSelection = 150;
+const uint8_t kGlassFrameInactiveTabAlphaMultiSelection = 150;
 
 // Alpha applied to all elements save the selected tabs.
-static const uint8_t kInactiveTabAndNewTabButtonAlphaAsh = 230;
-static const uint8_t kInactiveTabAndNewTabButtonAlpha = 255;
+const uint8_t kInactiveTabAndNewTabButtonAlphaAsh = 230;
+const uint8_t kInactiveTabAndNewTabButtonAlpha = 255;
 
 // Inverse ratio of the width of a tab edge to the width of the tab. When
 // hovering over the left or right edge of a tab, the drop indicator will
 // point between tabs.
-static const int kTabEdgeRatioInverse = 4;
+const int kTabEdgeRatioInverse = 4;
 
 // Size of the drop indicator.
-static int drop_indicator_width;
-static int drop_indicator_height;
+int drop_indicator_width;
+int drop_indicator_height;
 
 // Max number of stacked tabs.
-static const int kMaxStackedCount = 4;
+const int kMaxStackedCount = 4;
 
 // Padding between stacked tabs.
-static const int kStackedPadding = 6;
+const int kStackedPadding = 6;
 
 // 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 kNewTabButtonHorizontalOffset = -8;
 const int kPinnedToNonPinnedOffset = 2;
 #else
+const int kNewTabButtonHorizontalOffset = -11;
 const int kPinnedToNonPinnedOffset = 3;
 #endif
 
-base::string16 GetClipboardText() {
-  if (!ui::Clipboard::IsSupportedClipboardType(ui::CLIPBOARD_TYPE_SELECTION))
-    return base::string16();
-  ui::Clipboard* clipboard = ui::Clipboard::GetForCurrentThread();
-  CHECK(clipboard);
-  base::string16 clipboard_text;
-  clipboard->ReadText(ui::CLIPBOARD_TYPE_SELECTION, &clipboard_text);
-  return clipboard_text;
+// Returns the width needed for the new tab button (and padding).
+int GetNewTabButtonWidth() {
+  return TabStrip::kNewTabButtonAssetWidth + kNewTabButtonHorizontalOffset;
 }
 
 // Animation delegate used for any automatic tab movement.  Hides the tab if it
 // is not fully visible within the tabstrip area, to prevent overflow clipping.
 class TabAnimationDelegate : public gfx::AnimationDelegate {
  public:
   TabAnimationDelegate(TabStrip* tab_strip, Tab* tab);
   ~TabAnimationDelegate() override;
 
   void AnimationProgressed(const gfx::Animation* animation) override;
@@ skipping 195 matching lines @@
 void NewTabButton::OnGestureEvent(ui::GestureEvent* event) {
   // Consume all gesture events here so that the parent (Tab) does not
   // start consuming gestures.
   views::ImageButton::OnGestureEvent(event);
   event->SetHandled();
 }
 
 bool NewTabButton::GetHitTestMask(gfx::Path* mask) const {
   DCHECK(mask);
 
-  // When the button is sized to the top of the tab strip, we want the hit
-  // test mask to be defined as the complete (rectangular) bounds of the
-  // button.
   if (tab_strip_->SizeTabButtonToTopOfTabStrip()) {
+    // When the button is sized to the top of the tab strip, we want the hit
+    // test mask to be defined as the complete (rectangular) bounds of the
+    // button.
     gfx::Rect button_bounds(GetContentsBounds());
     button_bounds.set_x(GetMirroredXForRect(button_bounds));
     mask->addRect(RectToSkRect(button_bounds));
-    return true;
+  } else {
+    SkScalar w = SkIntToScalar(width());
+    SkScalar v_offset = SkIntToScalar(TabStrip::kNewTabButtonVerticalOffset);
+
+    // These values are defined by the shape of the new tab image. Should that
+    // image ever change, these values will need to be updated. They're so
+    // custom it's not really worth defining constants for.
+    // These values are correct for regular and USE_ASH versions of the image.
+    mask->moveTo(0, v_offset + 1);
+    mask->lineTo(w - 7, v_offset + 1);
+    mask->lineTo(w - 4, v_offset + 4);
+    mask->lineTo(w, v_offset + 16);
+    mask->lineTo(w - 1, v_offset + 17);
+    mask->lineTo(7, v_offset + 17);
+    mask->lineTo(4, v_offset + 13);
+    mask->lineTo(0, v_offset + 1);
+    mask->close();
   }
 
-  SkScalar w = SkIntToScalar(width());
-  SkScalar v_offset = SkIntToScalar(TabStrip::kNewTabButtonVerticalOffset);
-
-  // These values are defined by the shape of the new tab image. Should that
-  // image ever change, these values will need to be updated. They're so
-  // custom it's not really worth defining constants for.
-  // These values are correct for regular and USE_ASH versions of the image.
-  mask->moveTo(0, v_offset + 1);
-  mask->lineTo(w - 7, v_offset + 1);
-  mask->lineTo(w - 4, v_offset + 4);
-  mask->lineTo(w, v_offset + 16);
-  mask->lineTo(w - 1, v_offset + 17);
-  mask->lineTo(7, v_offset + 17);
-  mask->lineTo(4, v_offset + 13);
-  mask->lineTo(0, v_offset + 1);
-  mask->close();
-
   return true;
 }
 
 bool NewTabButton::ShouldWindowContentsBeTransparent() const {
   return GetWidget() &&
          GetWidget()->GetTopLevelWidget()->ShouldWindowContentsBeTransparent();
 }
 
 gfx::ImageSkia NewTabButton::GetBackgroundImage(
     views::CustomButton::ButtonState state,
@@ skipping 144 matching lines @@
 
 void TabStrip::RemoveTabDelegate::AnimationCanceled(
     const gfx::Animation* animation) {
   AnimationEnded(animation);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // TabStrip, public:
 
 // static
-const char TabStrip::kViewClassName[] = "TabStrip";
 const int TabStrip::kNewTabButtonVerticalOffset = 7;
 const int TabStrip::kNewTabButtonAssetWidth = 34;
-const int TabStrip::kNewTabButtonAssetHeight = 18;
-#if defined(OS_MACOSX)
-const int TabStrip::kNewTabButtonHorizontalOffset = -8;
-#else
-const int TabStrip::kNewTabButtonHorizontalOffset = -11;
-#endif
 
 TabStrip::TabStrip(TabStripController* controller)
     : controller_(controller),
       newtab_button_(NULL),
       current_inactive_width_(Tab::GetStandardSize().width()),
       current_active_width_(Tab::GetStandardSize().width()),
       available_width_for_tabs_(-1),
       in_tab_close_(false),
       animation_container_(new gfx::AnimationContainer()),
       bounds_animator_(this),
@@ skipping 202 matching lines @@
   // If the tab is currently clipped, it shouldn't be visible.  Note that we
   // allow dragged tabs to draw over the "New Tab button" region as well,
   // because either the New Tab button will be hidden, or the dragged tabs will
   // be animating back to their normal positions and we don't want to hide them
   // in the New Tab button region in case they re-appear after leaving it.
   // (This prevents flickeriness.)  We never draw non-dragged tabs in New Tab
   // button area, even when the button is invisible, so that they don't appear
   // to "pop in" when the button disappears.
   // TODO: Probably doesn't work for RTL
   int right_edge = tab->bounds().right();
-  const int visible_width = tab->dragging() ? width() : tab_area_width();
+  const int visible_width = tab->dragging() ? width() : GetTabAreaWidth();
   if (right_edge > visible_width)
     return false;
 
   // Non-clipped dragging tabs should always be visible.
   if (tab->dragging())
     return true;
 
   // Let all non-clipped closing tabs be visible.  These will probably finish
   // closing before the user changes the active tab, so there's little reason to
   // try and make the more complex logic below apply.
   if (tab->closing())
     return true;
 
   // Now we need to check whether the tab isn't currently clipped, but could
   // become clipped if we changed the active tab, widening either this tab or
   // the tabstrip portion before it.
 
   // Pinned tabs don't change size when activated, so any tab in the pinned tab
   // region is safe.
   if (tab->data().pinned)
     return true;
 
   // If the active tab is on or before this tab, we're safe.
   if (controller_->GetActiveIndex() <= GetModelIndexOfTab(tab))
     return true;
 
   // We need to check what would happen if the active tab were to move to this
   // tab or before.
   return (right_edge + current_active_width_ - current_inactive_width_) <=
-         tab_area_width();
+          GetTabAreaWidth();
 }
 
 void TabStrip::PrepareForCloseAt(int model_index, CloseTabSource source) {
   if (!in_tab_close_ && IsAnimating()) {
     // Cancel any current animations. We do this as remove uses the current
     // ideal bounds and we need to know ideal bounds is in a good state.
     StopAnimating(true);
   }
 
   if (!GetWidget())
@@ skipping 558 matching lines @@
   // And the dragged tabs.
   for (size_t i = 0; i < tabs_dragging.size(); ++i)
     tabs_dragging[i]->Paint(context);
 
   // If the active tab is being dragged, it goes last.
   if (active_tab && is_dragging)
     active_tab->Paint(context);
 }
 
 const char* TabStrip::GetClassName() const {
+  static const char kViewClassName[] = "TabStrip";
   return kViewClassName;
 }
 
 gfx::Size TabStrip::GetPreferredSize() const {
   int needed_tab_width;
   if (touch_layout_ || adjust_layout_) {
     // For stacked tabs the minimum size is calculated as the size needed to
     // handle showing any number of tabs.
     needed_tab_width =
         Tab::GetTouchWidth() + (2 * kStackedPadding * kMaxStackedCount);
@@ skipping 12 matching lines @@
     if (tab_count() > 1)
       needed_tab_width -= (tab_count() - 1) * tab_overlap;
 
     // Don't let the tabstrip shrink smaller than is necessary to show one tab,
     // and don't force it to be larger than is necessary to show 20 tabs.
     const int largest_min_tab_width =
         min_selected_width + 19 * (min_unselected_width - tab_overlap);
     needed_tab_width = std::min(
         std::max(needed_tab_width, min_selected_width), largest_min_tab_width);
   }
-  return gfx::Size(needed_tab_width + new_tab_button_width(),
+  return gfx::Size(needed_tab_width + GetNewTabButtonWidth(),
                    immersive_style_ ? Tab::GetImmersiveHeight()
                                     : Tab::GetMinimumInactiveSize().height());
 }
 
 void TabStrip::OnDragEntered(const DropTargetEvent& event) {
   // Force animations to stop, otherwise it makes the index calculation tricky.
   StopAnimating(true);
 
   UpdateDropIndex(event);
 
@@ skipping 90 matching lines @@
   return Tab::GetImmersiveHeight();
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // TabStrip, private:
 
 void TabStrip::Init() {
   set_id(VIEW_ID_TAB_STRIP);
   // So we get enter/exit on children to switch stacked layout on and off.
   set_notify_enter_exit_on_child(true);
-  newtab_button_bounds_.SetRect(0,
-                                0,
-                                kNewTabButtonAssetWidth,
-                                kNewTabButtonAssetHeight +
-                                    kNewTabButtonVerticalOffset);
+  newtab_button_bounds_.SetRect(
+      0, 0, kNewTabButtonAssetWidth,
+      kNewTabButtonHeight + kNewTabButtonVerticalOffset);
   newtab_button_ = new NewTabButton(this, this);
   newtab_button_->SetTooltipText(
       l10n_util::GetStringUTF16(IDS_TOOLTIP_NEW_TAB));
   newtab_button_->SetAccessibleName(
       l10n_util::GetStringUTF16(IDS_ACCNAME_NEWTAB));
   newtab_button_->SetImageAlignment(views::ImageButton::ALIGN_LEFT,
                                     views::ImageButton::ALIGN_BOTTOM);
   newtab_button_->SetEventTargeter(
       scoped_ptr<views::ViewTargeter>(new views::ViewTargeter(newtab_button_)));
   AddChildView(newtab_button_);
@@ skipping 95 matching lines @@
 }
 
 void TabStrip::DoLayout() {
   last_layout_size_ = size();
 
   StopAnimating(false);
 
   SwapLayoutIfNecessary();
 
   if (touch_layout_)
-    touch_layout_->SetWidth(tab_area_width());
+    touch_layout_->SetWidth(GetTabAreaWidth());
 
   GenerateIdealBounds();
 
   views::ViewModelUtils::SetViewBoundsToIdealBounds(tabs_);
   SetTabVisibility();
 
   SchedulePaint();
 
   bounds_animator_.StopAnimatingView(newtab_button_);
   newtab_button_->SetBoundsRect(newtab_button_bounds_);
@@ skipping 67 matching lines @@
       int new_x = std::max(new_bounds.x() + delta, max_x);
       if (new_x == max_x && !tab_at(i)->data().pinned && !is_active_pinned &&
           new_bounds.width() != active_width)
         new_x += (active_width - new_bounds.width());
       new_bounds.set_x(new_x);
       tabs_.set_ideal_bounds(i, new_bounds);
     }
   } else {
     // Drag the tabs to the right, stacking tabs after the active tab.
     const int last_tab_width = ideal_bounds(tab_count() - 1).width();
-    const int last_tab_x = tab_area_width() - last_tab_width;
+    const int last_tab_x = GetTabAreaWidth() - last_tab_width;
     if (active_index == tab_count() - 1 &&
         ideal_bounds(tab_count() - 1).x() == last_tab_x)
       return;
     const int adjusted_delta =
         std::min(last_tab_x -
                      kStackedPadding * std::min(tab_count() - active_index - 1,
                                                 kMaxStackedCount) -
                      ideal_bounds(active_index).x(),
                  delta);
     for (int last_index = tab_count() - 1, i = last_index; i >= active_index;
@@ skipping 566 matching lines @@
       tab_at(i)->set_dragging(false);
   }
 }
 
 void TabStrip::GenerateIdealBounds() {
   if (tab_count() == 0)
     return;  // Should only happen during creation/destruction, ignore.
 
   if (!touch_layout_) {
     const int available_width = (available_width_for_tabs_ < 0)
-                                    ? tab_area_width()
+                                    ?  GetTabAreaWidth()
                                     : available_width_for_tabs_;
     const std::vector<gfx::Rect> tabs_bounds =
         CalculateBounds(GetTabSizeInfo(), GetPinnedTabCount(), tab_count(),
                         controller_->GetActiveIndex(), available_width,
                         &current_active_width_, &current_inactive_width_);
     DCHECK_EQ(static_cast<size_t>(tab_count()), tabs_bounds.size());
 
     for (size_t i = 0; i < tabs_bounds.size(); ++i)
       tabs_.set_ideal_bounds(i, tabs_bounds[i]);
   }
@@ skipping 16 matching lines @@
   CalculateBoundsForPinnedTabs(GetTabSizeInfo(), num_pinned_tabs, tab_count(),
                                &tab_bounds);
   for (int i = 0; i < num_pinned_tabs; ++i)
     tabs_.set_ideal_bounds(i, tab_bounds[i]);
   return (num_pinned_tabs < tab_count())
              ? tab_bounds[num_pinned_tabs].x()
              : tab_bounds[num_pinned_tabs - 1].right() -
                    GetLayoutConstant(TABSTRIP_TAB_OVERLAP);
 }
 
+int TabStrip::GetTabAreaWidth() const {
+  return width() - GetNewTabButtonWidth();
+}
+
 void TabStrip::StartResizeLayoutAnimation() {
   PrepareForAnimation();
   GenerateIdealBounds();
   AnimateToIdealBounds();
 }
 
 void TabStrip::StartPinnedTabAnimation() {
   in_tab_close_ = false;
   available_width_for_tabs_ = -1;
 
@@ skipping 129 matching lines @@
 
   if (needs_touch) {
     gfx::Size tab_size(Tab::GetMinimumActiveSize());
     tab_size.set_width(Tab::GetTouchWidth());
     touch_layout_.reset(new StackedTabStripLayout(
                             tab_size,
                             GetLayoutConstant(TABSTRIP_TAB_OVERLAP),
                             kStackedPadding,
                             kMaxStackedCount,
                             &tabs_));
-    touch_layout_->SetWidth(tab_area_width());
+    touch_layout_->SetWidth(GetTabAreaWidth());
     // This has to be after SetWidth() as SetWidth() is going to reset the
     // bounds of the pinned tabs (since StackedTabStripLayout doesn't yet know
     // how many pinned tabs there are).
     GenerateIdealBoundsForPinnedTabs(NULL);
     touch_layout_->SetXAndPinnedCount(GetStartXForNormalTabs(),
                                     GetPinnedTabCount());
     touch_layout_->SetActiveIndex(controller_->GetActiveIndex());
 
     content::RecordAction(UserMetricsAction("StackedTab_EnteredStackedLayout"));
   } else {
     touch_layout_.reset();
   }
   PrepareForAnimation();
   GenerateIdealBounds();
   SetTabVisibility();
   AnimateToIdealBounds();
 }
 
 bool TabStrip::NeedsTouchLayout() const {
   if (!stacked_layout_)
     return false;
 
   int pinned_tab_count = GetPinnedTabCount();
   int normal_count = tab_count() - pinned_tab_count;
   if (normal_count <= 1 || normal_count == pinned_tab_count)
     return false;
   const int overlap = GetLayoutConstant(TABSTRIP_TAB_OVERLAP);
   return (Tab::GetTouchWidth() * normal_count - overlap * (normal_count - 1)) >
-      tab_area_width() - GetStartXForNormalTabs();
+      GetTabAreaWidth() - GetStartXForNormalTabs();
 }
 
 void TabStrip::SetResetToShrinkOnExit(bool value) {
   if (!adjust_layout_)
     return;
 
   if (value && !stacked_layout_)
     value = false;  // We're already using shrink (not stacked) layout.
 
   if (value == reset_to_shrink_on_exit_)
     return;
 
   reset_to_shrink_on_exit_ = value;
   // Add an observer so we know when the mouse moves out of the tabstrip.
   if (reset_to_shrink_on_exit_)
     AddMessageLoopObserver();
   else
     RemoveMessageLoopObserver();
 }
 
 void TabStrip::ButtonPressed(views::Button* sender, const ui::Event& event) {
   if (sender == newtab_button_) {
     content::RecordAction(UserMetricsAction("NewTab_Button"));
     UMA_HISTOGRAM_ENUMERATION("Tab.NewTab", TabStripModel::NEW_TAB_BUTTON,
                               TabStripModel::NEW_TAB_ENUM_COUNT);
     if (event.IsMouseEvent()) {
       const ui::MouseEvent& mouse = static_cast<const ui::MouseEvent&>(event);
       if (mouse.IsOnlyMiddleMouseButton()) {
-        base::string16 clipboard_text = GetClipboardText();
-        if (!clipboard_text.empty())
-          controller()->CreateNewTabWithLocation(clipboard_text);
+        if (ui::Clipboard::IsSupportedClipboardType(
+            ui::CLIPBOARD_TYPE_SELECTION)) {
+          ui::Clipboard* clipboard = ui::Clipboard::GetForCurrentThread();
+          CHECK(clipboard);
+          base::string16 clipboard_text;
+          clipboard->ReadText(ui::CLIPBOARD_TYPE_SELECTION, &clipboard_text);
+          if (!clipboard_text.empty())
+            controller()->CreateNewTabWithLocation(clipboard_text);
+        }
         return;
       }
     }
 
     controller()->CreateNewTab();
     if (event.type() == ui::ET_GESTURE_TAP)
       TouchUMA::RecordGestureAction(TouchUMA::GESTURE_NEWTAB_TAP);
   }
 }
 
@@ skipping 117 matching lines @@
           ConvertPointToViewAndGetEventHandler(this, newtab_button_, point);
       if (view)
         return view;
     }
     Tab* tab = FindTabForEvent(point);
     if (tab)
       return ConvertPointToViewAndGetEventHandler(this, tab, point);
   }
   return this;
 }