Paint tab-loading throbbers into a ui::Layer.

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 <algorithm>
 #include <iterator>
 #include <string>
 #include <vector>
@@ skipping 1160 matching lines @@
 
   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) {
+  const bool dragging = drag_controller_ && drag_controller_->started_drag();
   // Only touch layout needs to restrict the clip.
-  if (!touch_layout_ && !IsStackingDraggedTabs())
+  if (!touch_layout_ && !dragging)
     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();
+  int active_index =
+      dragging ? controller_->GetActiveIndex() : touch_layout_->active_index();
   if (active_index == tab_count())
     active_index--;
 
   if (index < active_index) {
     if (tab_at(index)->x() == tab_at(index + 1)->x())
       return false;
 
-    if (tab_at(index)->x() > tab_at(index + 1)->x())
-      return true;  // Can happen during dragging.
-
-    clip->SetRect(
-        0, 0, tab_at(index + 1)->x() - tab_at(index)->x() + kStackedTabLeftClip,
-        tab_at(index)->height());
+    if (tab_at(index)->x() > tab_at(index + 1)->x()) {
+      // Can happen during dragging.
+      int x = tab_at(index)->x() - tab_at(index + 1)->x();
+      clip->SetRect(x, 0, tab_at(index)->width() - x, tab_at(index)->height());
+    } else {
+      clip->SetRect(0, 0, tab_at(index + 1)->x() - tab_at(index)->x() +
+                              kStackedTabLeftClip,
+                    tab_at(index)->height());
+    }
   } else if (index > active_index && index > 0) {
     const gfx::Rect& tab_bounds(tab_at(index)->bounds());
     const gfx::Rect& previous_tab_bounds(tab_at(index - 1)->bounds());
     if (tab_bounds.x() == previous_tab_bounds.x())
       return false;
 
-    if (tab_bounds.x() < previous_tab_bounds.x())
-      return true;  // Can happen during dragging.
-
-    if (previous_tab_bounds.right() - GetLayoutConstant(TABSTRIP_TAB_OVERLAP) !=
-        tab_bounds.x()) {
+    if (tab_bounds.x() < previous_tab_bounds.x()) {
+      // Can happen during dragging.
+      int x = previous_tab_bounds.x() - tab_bounds.x();
+      clip->SetRect(x, 0, tab_bounds.width() - x, tab_bounds.height());
+    } else if (previous_tab_bounds.right() -
+                   GetLayoutConstant(TABSTRIP_TAB_OVERLAP) !=
+               tab_bounds.x()) {
       int x = previous_tab_bounds.right() - tab_bounds.x() -
           kStackedTabRightClip;
       clip->SetRect(x, 0, tab_bounds.width() - x, tab_bounds.height());
     }
   }
   return true;
 }
 
 bool TabStrip::IsImmersiveStyle() const {
   return immersive_style_;
@@ skipping 519 matching lines @@
       new_bounds.set_x(std::min(min_x, new_bounds.x() + delta));
       tabs_.set_ideal_bounds(i, new_bounds);
     }
     if (ideal_bounds(tab_count() - 1).right() >= newtab_button_->x())
       newtab_button_->SetVisible(false);
   }
   views::ViewModelUtils::SetViewBoundsToIdealBounds(tabs_);
   SchedulePaint();
 }
 
-bool TabStrip::IsStackingDraggedTabs() const {
-  return drag_controller_.get() && drag_controller_->started_drag() &&
-      (drag_controller_->move_behavior() ==
-       TabDragController::MOVE_VISIBILE_TABS);
-}
-
 void TabStrip::LayoutDraggedTabsAt(const Tabs& tabs,
                                    Tab* active_tab,
                                    const gfx::Point& location,
                                    bool initial_drag) {
   // Immediately hide the new tab button if the last tab is being dragged.
   const Tab* last_visible_tab = GetLastVisibleTab();
   if (last_visible_tab && last_visible_tab->dragging())
     newtab_button_->SetVisible(false);
   std::vector<gfx::Rect> bounds;
   CalculateBoundsForDraggedTabs(tabs, &bounds);
@@ skipping 918 matching lines @@
           ConvertPointToViewAndGetEventHandler(this, newtab_button_, point);
       if (view)
         return view;
     }
     Tab* tab = FindTabForEvent(point);
     if (tab)
       return ConvertPointToViewAndGetEventHandler(this, tab, point);
   }
   return this;
 }