RenderFrame: flesh out Observer

chrome/renderer/chrome_content_renderer_client.cc

 // Copyright (c) 2012 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/renderer/chrome_content_renderer_client.h"
 
 #include "base/command_line.h"
 #include "base/debug/crash_logging.h"
 #include "base/logging.h"
 #include "base/metrics/histogram.h"
@@ skipping 359 matching lines @@
   // TODO(jam): when a RenderFrame is per WebFrame, this can be simplified by
   // getting a RenderFrame's WebFrame and calling its parent() method.
   if (render_frame->GetRenderView()->GetMainRenderFrame() != render_frame) {
     // Avoid any race conditions from having the browser tell subframes that
     // they're prerendering.
     if (prerender::PrerenderHelper::IsPrerendering(
             render_frame->GetRenderView()->GetMainRenderFrame())) {
       new prerender::PrerenderHelper(render_frame);
     }
   }
+
+  if (!render_frame->GetWebFrame()->parent()) {
+    // Only attach NetErrorHelper to the main frame, since only the main frame
+    // should get error pages.
+    new NetErrorHelper(render_frame);
+  }
 }
 
 void ChromeContentRendererClient::RenderViewCreated(
     content::RenderView* render_view) {
   new extensions::ExtensionHelper(render_view, extension_dispatcher_.get());
   new PageLoadHistograms(render_view);
 #if defined(ENABLE_PRINTING)
   new printing::PrintWebViewHelper(render_view);
 #endif
 #if defined(ENABLE_SPELLCHECK)
   new SpellCheckProvider(render_view, spellcheck_.get());
 #endif
   new prerender::PrerendererClient(render_view);
 #if defined(FULL_SAFE_BROWSING)
   safe_browsing::MalwareDOMDetails::Create(render_view);
 #endif
 
   PasswordAutofillAgent* password_autofill_agent =
       new PasswordAutofillAgent(render_view);
   new AutofillAgent(render_view, password_autofill_agent);
 
   CommandLine* command_line = CommandLine::ForCurrentProcess();
   if (autofill::password_generation::IsPasswordGenerationEnabled())
     new PasswordGenerationAgent(render_view);
   if (command_line->HasSwitch(switches::kInstantProcess))
     new SearchBox(render_view);
 
   new ChromeRenderViewObserver(render_view, chrome_observer_.get());
-
-  new NetErrorHelper(render_view);
 }
 
 void ChromeContentRendererClient::SetNumberOfViews(int number_of_views) {
   base::debug::SetCrashKeyValue(crash_keys::kNumberOfViews,
                                 base::IntToString(number_of_views));
 }
 
 SkBitmap* ChromeContentRendererClient::GetSadPluginBitmap() {
   return const_cast<SkBitmap*>(ResourceBundle::GetSharedInstance().
       GetImageNamed(IDR_SAD_PLUGIN).ToSkBitmap());
@@ skipping 572 matching lines @@
         NOTREACHED() << "unable to load template. ID: " << resource_id;
       } else {
         base::DictionaryValue error_strings;
         LocalizedError::GetAppErrorStrings(failed_url, extension,
                                            &error_strings);
         // "t" is the id of the template's root node.
         *error_html = webui::GetTemplatesHtml(template_html, &error_strings,
                                               "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);
     }
   }
 
   if (error_description) {
     if (!extension)
       *error_description = LocalizedError::GetErrorDetails(error, is_post);
   }
 }
 
@@ skipping 378 matching lines @@
   CommandLine* command_line = CommandLine::ForCurrentProcess();
   return !command_line->HasSwitch(switches::kExtensionProcess);
 }
 
 blink::WebWorkerPermissionClientProxy*
 ChromeContentRendererClient::CreateWorkerPermissionClientProxy(
     content::RenderFrame* render_frame,
     blink::WebFrame* frame) {
   return new WorkerPermissionClientProxy(render_frame, frame);
 }