Rewire the throbber so that the timer for updating lives on BrowserView, not ...

chrome/browser/views/tabs/tab_strip.cc

 // Copyright (c) 2006-2008 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/views/tabs/tab_strip.h"
 
 #include "base/gfx/size.h"
 #include "chrome/app/theme/theme_resources.h"
 #include "chrome/browser/profile.h"
 #include "chrome/browser/tab_contents.h"
@@ skipping 14 matching lines @@
 #include "chrome/common/stl_util-inl.h"
 #include "chrome/common/win_util.h"
 #include "chrome/views/image_view.h"
 #include "chrome/views/painter.h"
 
 #include "generated_resources.h"
 
 #undef min
 #undef max
 
-using base::TimeDelta;
 using views::DropTargetEvent;
 
 static const int kDefaultAnimationDurationMs = 100;
 static const int kResizeLayoutAnimationDurationMs = 166;
 static const int kReorderAnimationDurationMs = 166;
 
-static const int kLoadingAnimationFrameTimeMs = 30;
 static const int kNewTabButtonHOffset = -5;
 static const int kNewTabButtonVOffset = 5;
 static const int kResizeTabsTimeMs = 300;
 static const int kSuspendAnimationsTimeMs = 200;
 static const int kTabHOffset = -16;
 static const int kTabStripAnimationVSlop = 40;
 
 // Size of the drop indicator.
 static int drop_indicator_width;
 static int drop_indicator_height;
@@ skipping 530 matching lines @@
   // the stopping of the active animation above may have left the TabStrip in a
   // bad (visual) state.
   Layout();
 }
 
 gfx::Rect TabStrip::GetIdealBounds(int index) {
   DCHECK(index >= 0 && index < GetTabCount());
   return tab_data_.at(index).ideal_bounds;
 }
 
+void TabStrip::UpdateLoadingAnimations() {
+  for (int i = 0, index = 0; i < GetTabCount(); ++i, ++index) {
+    Tab* current_tab = GetTabAt(i);
+    if (current_tab->closing()) {
+      --index;
+    } else {
+      TabContents* contents = model_->GetTabContentsAt(index);
+      if (!contents || !contents->is_loading()) {
+        current_tab->ValidateLoadingAnimation(Tab::ANIMATION_NONE);
+      } else if (contents->waiting_for_response()) {
+        current_tab->ValidateLoadingAnimation(Tab::ANIMATION_WAITING);
+      } else {
+        current_tab->ValidateLoadingAnimation(Tab::ANIMATION_LOADING);
+      }
+    }
+  }
+}
+
 ///////////////////////////////////////////////////////////////////////////////
 // TabStrip, views::View overrides:
 
 void TabStrip::PaintChildren(ChromeCanvas* canvas) {
   // Paint the tabs in reverse order, so they stack to the left.
   Tab* selected_tab = NULL;
   for (int i = GetTabCount() - 1; i >= 0; --i) {
     Tab* tab = GetTabAt(i);
     // We must ask the _Tab's_ model, not ourselves, because in some situations
     // the model will be different to this object, e.g. when a Tab is being
@@ skipping 271 matching lines @@
 }
 
 void TabStrip::TabChangedAt(TabContents* contents, int index) {
   // Index is in terms of the model. Need to make sure we adjust that index in
   // case we have an animation going.
   Tab* tab = GetTabAtAdjustForAnimation(index);
   tab->UpdateData(contents);
   tab->UpdateFromModel();
 }
 
-void TabStrip::TabValidateAnimations() {
-  if (model_->TabsAreLoading()) {
-    if (!loading_animation_timer_.IsRunning()) {
-      // Loads are happening, and the timer isn't running, so start it.
-      loading_animation_timer_.Start(
-          TimeDelta::FromMilliseconds(kLoadingAnimationFrameTimeMs), this,
-          &TabStrip::LoadingAnimationCallback);
-    }
-  } else {
-    if (loading_animation_timer_.IsRunning()) {
-      loading_animation_timer_.Stop();
-      // Loads are now complete, update the state if a task was scheduled.
-      LoadingAnimationCallback();
-    }
-  }
-}
-
 ///////////////////////////////////////////////////////////////////////////////
 // TabStrip, Tab::Delegate implementation:
 
 bool TabStrip::IsTabSelected(const Tab* tab) const {
   if (tab->closing())
     return false;
 
   int tab_count = GetTabCount();
   for (int i = 0, index = 0; i < tab_count; ++i, ++index) {
     Tab* current_tab = GetTabAt(i);
@@ skipping 335 matching lines @@
   }
 }
 
 void TabStrip::RemoveMessageLoopObserver() {
   if (added_as_message_loop_observer_) {
     MessageLoopForUI::current()->RemoveObserver(this);
     added_as_message_loop_observer_ = false;
   }
 }
 
-void TabStrip::LoadingAnimationCallback() {
-  for (int i = 0, index = 0; i < GetTabCount(); ++i, ++index) {
-    Tab* current_tab = GetTabAt(i);
-    if (current_tab->closing()) {
-      --index;
-    } else {
-      TabContents* contents = model_->GetTabContentsAt(index);
-      if (!contents || !contents->is_loading()) {
-        current_tab->ValidateLoadingAnimation(Tab::ANIMATION_NONE);
-      } else if (contents->waiting_for_response()) {
-        current_tab->ValidateLoadingAnimation(Tab::ANIMATION_WAITING);
-      } else {
-        current_tab->ValidateLoadingAnimation(Tab::ANIMATION_LOADING);
-      }
-    }
-  }
-
-  // Make sure the model delegates updates the animation as well.
-  TabStripModelDelegate* delegate;
-  if (model_ && (delegate = model_->delegate()))
-    delegate->ValidateLoadingAnimations();
-}
-
 gfx::Rect TabStrip::GetDropBounds(int drop_index,
                                   bool drop_before,
                                   bool* is_beneath) {
   DCHECK(drop_index != -1);
   int center_x;
   if (drop_index < GetTabCount()) {
     Tab* tab = GetTabAt(drop_index);
     if (drop_before)
       center_x = tab->x() - (kTabHOffset / 2);
     else
@@ skipping 264 matching lines @@
   return last_tab->x() + last_tab->width();
 }
 
 bool TabStrip::IsPointInTab(Tab* tab,
                             const gfx::Point& point_in_tabstrip_coords) {
   gfx::Point point_in_tab_coords(point_in_tabstrip_coords);
   View::ConvertPointToView(this, tab, &point_in_tab_coords);
   return tab->HitTest(point_in_tab_coords);
 }