Add error description to the DidFailProvisionalLoad callback.

content/browser/tab_contents/tab_contents.cc

 // Copyright (c) 2011 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 "content/browser/tab_contents/tab_contents.h"
 
 #include <cmath>
 
 #include "base/command_line.h"
 #include "base/metrics/histogram.h"
@@ skipping 894 matching lines @@
   if (!entry || entry->url() != source_url)
     return;
 
   // Notify observers about the provisional change in the main frame URL.
   FOR_EACH_OBSERVER(TabContentsObserver, observers_,
                     ProvisionalChangeToMainFrameUrl(target_url,
                                                     has_opener_set));
 }
 
 void TabContents::OnDidFailProvisionalLoadWithError(
-    int64 frame_id,
-    bool is_main_frame,
-    int error_code,
-    const GURL& url,
-    bool showing_repost_interstitial) {
-  VLOG(1) << "Failed Provisional Load: " << url.possibly_invalid_spec()
-          << ", error_code: " << error_code
-          << " is_main_frame: " << is_main_frame
-          << " showing_repost_interstitial: " << showing_repost_interstitial
-          << " frame_id: " << frame_id;
-  GURL validated_url(url);
+    const ViewHostMsg_DidFailProvisionalLoadWithError_Params& ipc_params) {

[jam, 2011/10/05 17:12:06]

nit: here and elsewhere, we usually just call this "params"

[mkosiba (inactive), 2011/10/05 17:53:18]

Done.

+  VLOG(1) << "Failed Provisional Load: " <<
+            ipc_params.url.possibly_invalid_spec()
+          << ", error_code: " << ipc_params.error_code
+          << ", error_description: " << ipc_params.error_description
+          << ", is_main_frame: " << ipc_params.is_main_frame
+          << ", showing_repost_interstitial: " <<
+            ipc_params.showing_repost_interstitial
+          << ", frame_id: " << ipc_params.frame_id;
+  GURL validated_url(ipc_params.url);
   render_view_host()->FilterURL(ChildProcessSecurityPolicy::GetInstance(),
       GetRenderProcessHost()->id(), &validated_url);
 
-  if (net::ERR_ABORTED == error_code) {
+  if (net::ERR_ABORTED == ipc_params.error_code) {
     // EVIL HACK ALERT! Ignore failed loads when we're showing interstitials.
     // This means that the interstitial won't be torn down properly, which is
     // bad. But if we have an interstitial, go back to another tab type, and
     // then load the same interstitial again, we could end up getting the first
     // interstitial's "failed" message (as a result of the cancel) when we're on
     // the second one.
     //
     // We can't tell this apart, so we think we're tearing down the current page
     // which will cause a crash later one. There is also some code in
     // RenderViewHostManager::RendererAbortedProvisionalLoad that is commented
@@ skipping 20 matching lines @@
     // navigation will still commit even if there is no pending entry.
     NavigationEntry* pending_entry = controller_.pending_entry();
     if (pending_entry)
       DidCancelLoading();
 
     render_manager_.RendererAbortedProvisionalLoad(render_view_host());
   }
 
   // Send out a notification that we failed a provisional load with an error.
   ProvisionalLoadDetails details(
-      is_main_frame, controller_.IsURLInPageNavigation(validated_url),
-      validated_url, std::string(), false, frame_id);
-  details.set_error_code(error_code);
+      ipc_params.is_main_frame,
+      controller_.IsURLInPageNavigation(validated_url),
+      validated_url,
+      std::string(),
+      false,
+      ipc_params.frame_id);
+  details.set_error_code(ipc_params.error_code);
 
   NotificationService::current()->Notify(
       content::NOTIFICATION_FAIL_PROVISIONAL_LOAD_WITH_ERROR,
       Source<NavigationController>(&controller_),
       Details<ProvisionalLoadDetails>(&details));
 
-  FOR_EACH_OBSERVER(TabContentsObserver, observers_,
-                    DidFailProvisionalLoad(frame_id, is_main_frame,
-                    validated_url, error_code));
+  FOR_EACH_OBSERVER(TabContentsObserver,
+                    observers_,
+                    DidFailProvisionalLoad(ipc_params.frame_id,
+                                           ipc_params.is_main_frame,
+                                           validated_url,
+                                           ipc_params.error_code,
+                                           ipc_params.error_description));
 }
 
 void TabContents::OnDidLoadResourceFromMemoryCache(
     const GURL& url,
     const std::string& security_info,
     const std::string& http_method,
     ResourceType::Type resource_type) {
   base::StatsCounter cache("WebKit.CacheHit");
   cache.Increment();
 
@@ skipping 964 matching lines @@
 }
 
 void TabContents::SwapInRenderViewHost(RenderViewHost* rvh) {
   render_manager_.SwapInRenderViewHost(rvh);
 }
 
 void TabContents::CreateViewAndSetSizeForRVH(RenderViewHost* rvh) {
   RenderWidgetHostView* rwh_view = view()->CreateViewForWidget(rvh);
   rwh_view->SetSize(view()->GetContainerSize());
 }