RenderFrame: flesh out Observer

chrome/renderer/net/net_error_helper.cc

 // Copyright (c) 2013 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/net/net_error_helper.h"
 
 #include <string>
 
 #include "base/json/json_writer.h"
 #include "base/metrics/histogram.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/values.h"
 #include "chrome/common/localized_error.h"
 #include "chrome/common/net/net_error_info.h"
 #include "chrome/common/render_messages.h"
 #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"
 #include "grit/renderer_resources.h"
 #include "ipc/ipc_message.h"
 #include "ipc/ipc_message_macros.h"
 #include "third_party/WebKit/public/platform/WebURL.h"
 #include "third_party/WebKit/public/platform/WebURLError.h"
 #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/WebFrame.h"
 #include "third_party/WebKit/public/web/WebView.h"
 #include "ui/base/resource/resource_bundle.h"
 #include "ui/base/webui/jstemplate_builder.h"
 #include "url/gurl.h"
 
 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 {
 
 // Number of seconds to wait for the alternate error page server.  If it takes
 // too long, just use the local error page.
 static const int kAlterErrorPageFetchTimeoutSec = 3000;
 
 NetErrorHelperCore::PageType GetLoadingPageType(const blink::WebFrame* frame) {
   GURL url = frame->provisionalDataSource()->request().url();
   if (!url.is_valid() || url.spec() != kUnreachableWebDataURL)
     return NetErrorHelperCore::NON_ERROR_PAGE;
   return NetErrorHelperCore::ERROR_PAGE;
 }
 
 NetErrorHelperCore::FrameType GetFrameType(const blink::WebFrame* frame) {
   if (!frame->parent())
     return NetErrorHelperCore::MAIN_FRAME;
   return NetErrorHelperCore::SUB_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) {
   core_.OnStartLoad(GetFrameType(frame), GetLoadingPageType(frame));
 }
 
@@ skipping 38 matching lines @@
   int resource_id = IDR_NET_ERROR_HTML;
   const base::StringPiece template_html(
       ResourceBundle::GetSharedInstance().GetRawDataResource(resource_id));
   if (template_html.empty()) {
     NOTREACHED() << "unable to load template.";
   } else {
     base::DictionaryValue error_strings;
     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");
   }
 }
 
 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();
   frame->loadHTMLString(html, GURL(kUnreachableWebDataURL), failed_url, true);
 }
 
 void NetErrorHelper::UpdateErrorPage(const blink::WebURLError& error,
                                      bool is_failed_post) {
   base::DictionaryValue error_strings;
   LocalizedError::GetStrings(error.reason,
                              error.domain.utf8(),
                              error.unreachableURL,
                              is_failed_post,
                              RenderThread::Get()->GetLocale(),
-                             render_view()->GetAcceptLanguages(),
+                             render_frame()->GetRenderView()->
+                                 GetAcceptLanguages(),
                              &error_strings);
 
   std::string json;
   JSONWriter::Write(&error_strings, &json);
 
   std::string js = "if (window.updateForDnsProbe) "
                    "updateForDnsProbe(" + json + ");";
   base::string16 js16;
   if (!base::UTF8ToUTF16(js.c_str(), js.length(), &js16)) {
     NOTREACHED();
     return;
   }
 
   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();
 
   alt_error_page_fetcher_.reset(
       content::ResourceFetcher::Create(
           url, frame, blink::WebURLRequest::TargetIsMainFrame,
           base::Bind(&NetErrorHelper::OnAlternateErrorPageRetrieved,
                      base::Unretained(this))));
 
@@ skipping 23 matching lines @@
   // The fetcher may only be deleted after |data| is passed to |core_|.  Move
   // it to a temporary to prevent any potential re-entrancy issues.
   scoped_ptr<content::ResourceFetcher> fetcher(
       alt_error_page_fetcher_.release());
   if (!response.isNull() && response.httpStatusCode() == 200) {
     core_.OnAlternateErrorPageFetched(data);
   } else {
     core_.OnAlternateErrorPageFetched("");
   }
 }