Synchronously update the loading state when a load starts so that the UI will...

chrome/browser/renderer_host/render_view_host.cc

 // Copyright (c) 2009 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/renderer_host/render_view_host.h"
 
 #include <string>
 #include <vector>
 
 #include "base/gfx/native_widget_types.h"
@@ skipping 208 matching lines @@
   // request.
   if (navigations_suspended_) {
     // Shouldn't be possible to have a second navigation while suspended, since
     // navigations will only be suspended during a cross-site request.  If a
     // second navigation occurs, WebContents will cancel this pending RVH
     // create a new pending RVH.
     DCHECK(!suspended_nav_message_.get());
     suspended_nav_message_.reset(nav_message);
   } else {
     Send(nav_message);
+
+    // Force the throbber to start. We do this because WebKit's "started
+    // loading" message will be received asynchronously from the UI of the
+    // browser. But we want to keep the throbber in sync with what's happening
+    // in the UI. For example, we want to start throbbing immediately when the
+    // user naivgates even if the renderer is delayed. There is also an issue
+    // with the throbber starting because the DOMUI (which controls whether the
+    // favicon is displayed) happens synchronously. If the start loading
+    // messages was asynchronous, then the default favicon would flash in.
+    delegate_->DidStartLoading(this);
   }
 }
 
 void RenderViewHost::LoadAlternateHTMLString(const std::string& html_text,
                                              bool new_navigation,
                                              const GURL& display_url,
                                              const std::string& security_info) {
   Send(new ViewMsg_LoadAlternateHTMLText(routing_id(), html_text,
                                          new_navigation, display_url,
                                          security_info));
@@ skipping 701 matching lines @@
 void RenderViewHost::OnMsgRequestMove(const gfx::Rect& pos) {
   delegate_->RequestMove(pos);
 }
 
 void RenderViewHost::OnMsgDidRedirectProvisionalLoad(int32 page_id,
                                                      const GURL& source_url,
                                                      const GURL& target_url) {
   delegate_->DidRedirectProvisionalLoad(page_id, source_url, target_url);
 }
 
-void RenderViewHost::OnMsgDidStartLoading(int32 page_id) {
-  delegate_->DidStartLoading(this, page_id);
+void RenderViewHost::OnMsgDidStartLoading() {
+  delegate_->DidStartLoading(this);
 }
 
-void RenderViewHost::OnMsgDidStopLoading(int32 page_id) {
-  delegate_->DidStopLoading(this, page_id);
+void RenderViewHost::OnMsgDidStopLoading() {
+  delegate_->DidStopLoading(this);
 }
 
 void RenderViewHost::OnMsgDidLoadResourceFromMemoryCache(
     const GURL& url,
     const std::string& frame_origin,
     const std::string& main_frame_origin,
     const std::string& security_info) {
   delegate_->DidLoadResourceFromMemoryCache(
       url, frame_origin, main_frame_origin, security_info);
 }
@@ skipping 386 matching lines @@
                                         int callback_id) {
   // TODO(aa): Here is where we can check that this renderer was supposed to be
   // able to call extension APIs.
   extension_function_dispatcher_->HandleRequest(name, args, callback_id);
 }
 
 void RenderViewHost::SendExtensionResponse(int callback_id,
                                            const std::string& response) {
   Send(new ViewMsg_ExtensionResponse(routing_id(), callback_id, response));
 }