Make the throbber throb sooner after you navigate. This fixes the new tab pag...

chrome/browser/browser.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/browser.h"
 
 #include "base/command_line.h"
 #include "base/idle_timer.h"
 #include "base/logging.h"
 #include "base/string_util.h"
@@ skipping 1639 matching lines @@
     controller->LoadURL(url, referrer, transition);
     // If the TabContents type has been swapped, we need to point to the current
     // active type otherwise there will be weirdness.
     new_contents = controller->active_contents();
     if (GetStatusBubble())
       GetStatusBubble()->Hide();
 
     // Synchronously update the location bar. This allows us to immediately
     // have the URL bar update when the user types something, rather than
     // going through the normal system of ScheduleUIUpdate which has a delay.
+    ScheduleUIUpdate(source, TabContents::INVALIDATE_URL |

[Ben Goodger (Google), 2009/04/04 17:27:59]

You might move this above the comment above since it's UpdateToolbar that does
the synchronous updating, or give this its own comment.

+                             TabContents::INVALIDATE_LOAD);
     UpdateToolbar(false);
   } else if (disposition == OFF_THE_RECORD) {
     OpenURLOffTheRecord(profile_, url);
     return;
   } else if (disposition != SUPPRESS_OPEN) {
     new_contents = AddTabWithURL(url, referrer, transition,
                                  disposition != NEW_BACKGROUND_TAB, instance);
   }
 
   if (disposition != NEW_BACKGROUND_TAB && source_tab_was_frontmost) {
@@ skipping 188 matching lines @@
 
   tabstrip_model_.DetachTabContentsAt(index);
   Browser* browser = Browser::CreateForApp(app_name, profile_, false);
   browser->tabstrip_model()->AppendTabContents(contents, true);
   browser->window()->Show();
 }
 
 void Browser::ContentsStateChanged(TabContents* source) {
   int index = tabstrip_model_.GetIndexOfTabContents(source);
   if (index != TabStripModel::kNoTab)
-    tabstrip_model_.UpdateTabContentsStateAt(index);
+    tabstrip_model_.UpdateTabContentsStateAt(index, true);
 }
 
 bool Browser::ShouldDisplayURLField() {
   return !IsApplication();
 }
 
 void Browser::BeforeUnloadFired(TabContents* tab,
                                 bool proceed,
                                 bool* proceed_to_fire_unload) {
   if (!is_attempting_to_close_browser_) {
@@ skipping 310 matching lines @@
 
 ///////////////////////////////////////////////////////////////////////////////
 // Browser, UI update coalescing and handling (private):
 
 void Browser::UpdateToolbar(bool should_restore_state) {
   window_->UpdateToolbar(GetSelectedTabContents(), should_restore_state);
 }
 
 void Browser::ScheduleUIUpdate(const TabContents* source,
                                unsigned changed_flags) {
-  // Synchronously update the URL.
+  // Do some synchronous updates.
   if (changed_flags & TabContents::INVALIDATE_URL &&
       source == GetSelectedTabContents()) {
     // Only update the URL for the current tab. Note that we do not update
     // the navigation commands since those would have already been updated
     // synchronously by NavigationStateChanged.
     UpdateToolbar(false);
+  }
+  if (changed_flags & TabContents::INVALIDATE_LOAD && source) {
+    // Update the loading state synchronously. This is so the throbber will
+    // immediately start/stop, which gives a more snappy feel. We want to do
+    // this for any tab so they start & stop quickly, but the source can be
+    // NULL, so we have to check for that.
+    tabstrip_model_.UpdateTabContentsStateAt(
+        tabstrip_model_.GetIndexOfController(source->controller()), true);
+  }
 
-    if (changed_flags == TabContents::INVALIDATE_URL)
-      return;  // Just had an update URL and nothing else.
-  }
+  // If the only updates were synchronously handled above, we're done.
+  if (changed_flags ==
+      (TabContents::INVALIDATE_URL | TabContents::INVALIDATE_LOAD))
+    return;
 
   // Save the dirty bits.
   scheduled_updates_.push_back(UIUpdate(source, changed_flags));
 
   if (chrome_updater_factory_.empty()) {
     // No task currently scheduled, start another.
     MessageLoop::current()->PostDelayedTask(FROM_HERE,
         chrome_updater_factory_.NewRunnableMethod(
             &Browser::ProcessPendingUIUpdates),
             kUIUpdateCoalescingTimeMS);
@@ skipping 59 matching lines @@
     if (flags & TabContents::INVALIDATE_FEEDLIST)
       window()->GetLocationBar()->UpdateFeedIcon();
 
     // Updating the URL happens synchronously in ScheduleUIUpdate.
 
     if (flags & TabContents::INVALIDATE_LOAD && GetStatusBubble())
       GetStatusBubble()->SetStatus(GetSelectedTabContents()->GetStatusText());
 
     if (invalidate_tab) {  // INVALIDATE_TITLE or INVALIDATE_FAVICON.
       tabstrip_model_.UpdateTabContentsStateAt(
-          tabstrip_model_.GetIndexOfController(contents->controller()));
+          tabstrip_model_.GetIndexOfController(contents->controller()), false);
       window_->UpdateTitleBar();
 
       if (contents == GetSelectedTabContents()) {
         TabContents* current_tab = GetSelectedTabContents();
         command_updater_.UpdateCommandEnabled(IDC_CREATE_SHORTCUTS,
             current_tab->type() == TAB_CONTENTS_WEB &&
             !current_tab->GetFavIcon().isNull());
       }
     }
 
@@ skipping 209 matching lines @@
 
   // We need to register the window position pref.
   std::wstring window_pref(prefs::kBrowserWindowPlacement);
   window_pref.append(L"_");
   window_pref.append(app_name);
   PrefService* prefs = g_browser_process->local_state();
   DCHECK(prefs);
 
   prefs->RegisterDictionaryPref(window_pref.c_str());
 }