RenderFrame: flesh out Observer

Add four new events to RenderFrameObserver: DidCreateDataSource,
DidStartProvisionalLoad, DidFailProvisionalLoad, DidFinishLoad; add code to send
the former three as needed.

TEST=unit,trybot
BUG=none

Review URL: https://codereview.chromium.org/137463002

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@247717 0039d316-1c4b-4281-b951-d872f2087c98

chrome/browser/net/net_error_tab_helper.cc

@@ -14,6 +14,7 @@
 #include "chrome/common/pref_names.h"
 #include "chrome/common/render_messages.h"
 #include "content/public/browser/browser_thread.h"
+#include "content/public/browser/render_frame_host.h"
 #include "net/base/net_errors.h"
 
 using chrome_common_net::DnsProbeStatus;
@@ -215,7 +216,9 @@ void NetErrorTabHelper::SendInfo() {
   DCHECK(dns_error_page_committed_);
 
   DVLOG(1) << "Sending status " << DnsProbeStatusToString(dns_probe_status_);
-  Send(new ChromeViewMsg_NetErrorInfo(routing_id(), dns_probe_status_));
+  content::RenderFrameHost* rfh = web_contents()->GetMainFrame();
+  rfh->Send(new ChromeViewMsg_NetErrorInfo(rfh->GetRoutingID(),
+                                           dns_probe_status_));
 
   if (!dns_probe_status_snoop_callback_.is_null())
     dns_probe_status_snoop_callback_.Run(dns_probe_status_);

chrome/browser/ui/alternate_error_tab_observer.cc

@@ -12,9 +12,11 @@
 #include "chrome/common/render_messages.h"
 #include "components/user_prefs/pref_registry_syncable.h"
 #include "content/public/browser/notification_service.h"
+#include "content/public/browser/render_frame_host.h"
 #include "content/public/browser/render_view_host.h"
 #include "content/public/browser/web_contents.h"
 
+using content::RenderFrameHost;
 using content::RenderViewHost;
 using content::WebContents;
 
@@ -93,6 +95,7 @@ void AlternateErrorPageTabObserver::OnAlternateErrorPagesEnabledChanged() {
 
 void AlternateErrorPageTabObserver::UpdateAlternateErrorPageURL(
     RenderViewHost* rvh) {
-  rvh->Send(new ChromeViewMsg_SetAltErrorPageURL(
-                rvh->GetRoutingID(), GetAlternateErrorPageURL()));
+  RenderFrameHost* rfh = rvh->GetMainFrame();
+  rfh->Send(new ChromeViewMsg_SetAltErrorPageURL(
+                rfh->GetRoutingID(), GetAlternateErrorPageURL()));
 }

chrome/renderer/chrome_content_renderer_client.cc

@@ -383,6 +383,12 @@ void ChromeContentRendererClient::RenderFrameCreated(
       new prerender::PrerenderHelper(render_frame);
     }
   }
+
+  if (render_frame->GetRenderView()->GetMainRenderFrame() == render_frame) {
+    // Only attach NetErrorHelper to the main frame, since only the main frame
+    // should get error pages.
+    new NetErrorHelper(render_frame);
+  }
 }
 
 void ChromeContentRendererClient::RenderViewCreated(
@@ -411,8 +417,6 @@ void ChromeContentRendererClient::RenderViewCreated(
     new SearchBox(render_view);
 
   new ChromeRenderViewObserver(render_view, chrome_observer_.get());
-
-  new NetErrorHelper(render_view);
 }
 
 void ChromeContentRendererClient::SetNumberOfViews(int number_of_views) {
@@ -1005,7 +1009,14 @@ void ChromeContentRendererClient::GetNavigationErrorStrings(
                                               "t");
       }
     } else {
-      NetErrorHelper* helper = NetErrorHelper::Get(render_view);
+      // TODO(ellyjones): change GetNavigationErrorStrings to take a RenderFrame
+      // instead of a RenderView, then pass that in.
+      // This is safe for now because we only install the NetErrorHelper on the
+      // main render frame anyway; see the TODO(ellyjones) in
+      // RenderFrameCreated.
+      content::RenderFrame* main_render_frame =
+          render_view->GetMainRenderFrame();
+      NetErrorHelper* helper = NetErrorHelper::Get(main_render_frame);
       helper->GetErrorHTML(frame, error, is_post, error_html);
     }
   }

chrome/renderer/net/net_error_helper.cc

@@ -16,6 +16,7 @@
 #include "content/public/common/content_client.h"
 #include "content/public/common/url_constants.h"
 #include "content/public/renderer/content_renderer_client.h"
+#include "content/public/renderer/render_frame.h"
 #include "content/public/renderer/render_thread.h"
 #include "content/public/renderer/render_view.h"
 #include "content/public/renderer/resource_fetcher.h"
@@ -27,6 +28,7 @@
 #include "third_party/WebKit/public/platform/WebURLRequest.h"
 #include "third_party/WebKit/public/platform/WebURLResponse.h"
 #include "third_party/WebKit/public/web/WebDataSource.h"
+#include "third_party/WebKit/public/web/WebDocument.h"
 #include "third_party/WebKit/public/web/WebFrame.h"
 #include "third_party/WebKit/public/web/WebView.h"
 #include "ui/base/resource/resource_bundle.h"
@@ -36,9 +38,9 @@
 using base::JSONWriter;
 using chrome_common_net::DnsProbeStatus;
 using chrome_common_net::DnsProbeStatusToString;
+using content::RenderFrame;
+using content::RenderFrameObserver;
 using content::RenderThread;
-using content::RenderView;
-using content::RenderViewObserver;
 using content::kUnreachableWebDataURL;
 
 namespace {
@@ -62,25 +64,27 @@ NetErrorHelperCore::FrameType GetFrameType(const blink::WebFrame* frame) {
 
 }  // namespace
 
-NetErrorHelper::NetErrorHelper(RenderView* render_view)
-    : RenderViewObserver(render_view),
-      content::RenderViewObserverTracker<NetErrorHelper>(render_view),
+NetErrorHelper::NetErrorHelper(RenderFrame* render_view)
+    : RenderFrameObserver(render_view),
+      content::RenderFrameObserverTracker<NetErrorHelper>(render_view),
       core_(this) {
 }
 
 NetErrorHelper::~NetErrorHelper() {
 }
 
-void NetErrorHelper::DidStartProvisionalLoad(blink::WebFrame* frame) {
+void NetErrorHelper::DidStartProvisionalLoad() {
+  blink::WebFrame* frame = render_frame()->GetWebFrame();
   core_.OnStartLoad(GetFrameType(frame), GetLoadingPageType(frame));
 }
 
-void NetErrorHelper::DidCommitProvisionalLoad(blink::WebFrame* frame,
-                                              bool is_new_navigation) {
+void NetErrorHelper::DidCommitProvisionalLoad(bool is_new_navigation) {
+  blink::WebFrame* frame = render_frame()->GetWebFrame();
   core_.OnCommitLoad(GetFrameType(frame));
 }
 
-void NetErrorHelper::DidFinishLoad(blink::WebFrame* frame) {
+void NetErrorHelper::DidFinishLoad() {
+  blink::WebFrame* frame = render_frame()->GetWebFrame();
   core_.OnFinishLoad(GetFrameType(frame));
 }
 
@@ -123,7 +127,8 @@ void NetErrorHelper::GenerateLocalizedErrorPage(const blink::WebURLError& error,
     LocalizedError::GetStrings(error.reason, error.domain.utf8(),
                                error.unreachableURL, is_failed_post,
                                RenderThread::Get()->GetLocale(),
-                               render_view()->GetAcceptLanguages(),
+                               render_frame()->GetRenderView()->
+                                   GetAcceptLanguages(),
                                &error_strings);
     // "t" is the id of the template's root node.
     *error_html = webui::GetTemplatesHtml(template_html, &error_strings, "t");
@@ -132,7 +137,7 @@ void NetErrorHelper::GenerateLocalizedErrorPage(const blink::WebURLError& error,
 
 void NetErrorHelper::LoadErrorPageInMainFrame(const std::string& html,
                                               const GURL& failed_url) {
-  blink::WebView* web_view = render_view()->GetWebView();
+  blink::WebView* web_view = render_frame()->GetRenderView()->GetWebView();
   if (!web_view)
     return;
   blink::WebFrame* frame = web_view->mainFrame();
@@ -147,7 +152,8 @@ void NetErrorHelper::UpdateErrorPage(const blink::WebURLError& error,
                              error.unreachableURL,
                              is_failed_post,
                              RenderThread::Get()->GetLocale(),
-                             render_view()->GetAcceptLanguages(),
+                             render_frame()->GetRenderView()->
+                                 GetAcceptLanguages(),
                              &error_strings);
 
   std::string json;
@@ -162,13 +168,13 @@ void NetErrorHelper::UpdateErrorPage(const blink::WebURLError& error,
   }
 
   base::string16 frame_xpath;
-  render_view()->EvaluateScript(frame_xpath, js16, 0, false);
+  render_frame()->GetRenderView()->EvaluateScript(frame_xpath, js16, 0, false);
 }
 
 void NetErrorHelper::FetchErrorPage(const GURL& url) {
   DCHECK(!alt_error_page_fetcher_.get());
 
-  blink::WebView* web_view = render_view()->GetWebView();
+  blink::WebView* web_view = render_frame()->GetRenderView()->GetWebView();
   if (!web_view)
     return;
   blink::WebFrame* frame = web_view->mainFrame();

chrome/renderer/net/net_error_helper.h

@@ -9,8 +9,8 @@
 
 #include "chrome/common/net/net_error_info.h"
 #include "chrome/renderer/net/net_error_helper_core.h"
-#include "content/public/renderer/render_view_observer.h"
-#include "content/public/renderer/render_view_observer_tracker.h"
+#include "content/public/renderer/render_frame_observer.h"
+#include "content/public/renderer/render_frame_observer_tracker.h"
 
 class GURL;
 
@@ -28,18 +28,17 @@ struct WebURLError;
 // browser side and updates the error page with more details (currently, just
 // DNS probe results) if/when available.
 class NetErrorHelper
-    : public content::RenderViewObserver,
-      public content::RenderViewObserverTracker<NetErrorHelper>,
+    : public content::RenderFrameObserver,
+      public content::RenderFrameObserverTracker<NetErrorHelper>,
       public NetErrorHelperCore::Delegate {
  public:
-  explicit NetErrorHelper(content::RenderView* render_view);
+  explicit NetErrorHelper(content::RenderFrame* render_view);
   virtual ~NetErrorHelper();
 
-  // RenderViewObserver implementation.
-  virtual void DidStartProvisionalLoad(blink::WebFrame* frame) OVERRIDE;
-  virtual void DidCommitProvisionalLoad(blink::WebFrame* frame,
-                                        bool is_new_navigation) OVERRIDE;
-  virtual void DidFinishLoad(blink::WebFrame* frame) OVERRIDE;
+  // RenderFrameObserver implementation.
+  virtual void DidStartProvisionalLoad() OVERRIDE;
+  virtual void DidCommitProvisionalLoad(bool is_new_navigation) OVERRIDE;
+  virtual void DidFinishLoad() OVERRIDE;
   virtual void OnStop() OVERRIDE;
 
   // IPC::Listener implementation.

content/public/renderer/render_frame_observer.h

@@ -13,6 +13,7 @@
 
 namespace blink {
 class WebFrame;
+struct WebURLError;
 }
 
 namespace content {
@@ -33,8 +34,14 @@ class CONTENT_EXPORT RenderFrameObserver : public IPC::Listener,
   // Called when a Pepper plugin is created.
   virtual void DidCreatePepperPlugin(RendererPpapiHost* host) {}
 
+  // Called when a load is explicitly stopped by the user or browser.
+  virtual void OnStop() {}
+
   // These match the Blink API notifications
   virtual void DidCommitProvisionalLoad(bool is_new_navigation) {}
+  virtual void DidStartProvisionalLoad() {}
+  virtual void DidFailProvisionalLoad(const blink::WebURLError& error) {}
+  virtual void DidFinishLoad() {}
 
   // IPC::Listener implementation.
   virtual bool OnMessageReceived(const IPC::Message& message) OVERRIDE;

content/renderer/render_frame_impl.cc

@@ -862,6 +862,10 @@ void RenderFrameImpl::didStartProvisionalLoad(blink::WebFrame* frame) {
       RenderViewObserver, render_view_->observers(),
       DidStartProvisionalLoad(frame));
 
+  FOR_EACH_OBSERVER(
+      RenderFrameObserver, observers_,
+      DidStartProvisionalLoad());
+
   Send(new FrameHostMsg_DidStartProvisionalLoadForFrame(
        routing_id_, frame->identifier(),
        frame->parent() ? frame->parent()->identifier() : -1,
@@ -901,6 +905,9 @@ void RenderFrameImpl::didFailProvisionalLoad(
   // Call out to RenderViewImpl, so observers are notified.
   render_view_->didFailProvisionalLoad(frame, error);
 
+  FOR_EACH_OBSERVER(RenderFrameObserver, observers_,
+                    DidFailProvisionalLoad(error));
+
   bool show_repost_interstitial =
       (error.reason == net::ERR_CACHE_MISS &&
        EqualsASCII(failed_request.httpMethod(), "POST"));
@@ -1067,6 +1074,8 @@ void RenderFrameImpl::didFinishLoad(blink::WebFrame* frame) {
   // TODO(nasko): Move implementation here. No state needed, just observers
   // notification before sending message to the browser process.
   render_view_->didFinishLoad(frame);
+  FOR_EACH_OBSERVER(RenderFrameObserver, observers_,
+                    DidFinishLoad());
 }
 
 void RenderFrameImpl::didNavigateWithinPage(blink::WebFrame* frame,
@@ -1502,4 +1511,8 @@ void RenderFrameImpl::RemoveObserver(RenderFrameObserver* observer) {
   observers_.RemoveObserver(observer);
 }
 
+void RenderFrameImpl::OnStop() {
+  FOR_EACH_OBSERVER(RenderFrameObserver, observers_, OnStop());
+}
+
 }  // namespace content

content/renderer/render_frame_impl.h

@@ -87,6 +87,9 @@ class CONTENT_EXPORT RenderFrameImpl
   // This is called right after creation with the WebFrame for this RenderFrame.
   void SetWebFrame(blink::WebFrame* web_frame);
 
+  // Notification from RenderView.
+  virtual void OnStop();
+
 #if defined(ENABLE_PLUGINS)
   // Notification that a PPAPI plugin has been created.
   void PepperPluginCreated(RendererPpapiHost* host);

content/renderer/render_view_impl.cc

@@ -1583,6 +1583,7 @@ void RenderViewImpl::OnStop() {
   if (webview())
     webview()->mainFrame()->stopLoading();
   FOR_EACH_OBSERVER(RenderViewObserver, observers_, OnStop());
+  main_render_frame_->OnStop();
 }
 
 // Reload current focused frame.