Rename WebKit namespace to blink (part 4)

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"
@@ skipping 20 matching lines @@
 using chrome_common_net::DnsProbeStatus;
 using chrome_common_net::DnsProbeStatusIsFinished;
 using chrome_common_net::DnsProbeStatusToString;
 using content::RenderThread;
 using content::RenderView;
 using content::RenderViewObserver;
 using content::kUnreachableWebDataURL;
 
 namespace {
 
-bool IsLoadingErrorPage(WebKit::WebFrame* frame) {
+bool IsLoadingErrorPage(blink::WebFrame* frame) {
   GURL url = frame->provisionalDataSource()->request().url();
   if (!url.is_valid())
     return false;
   return url.spec() == kUnreachableWebDataURL;
 }
 
-bool IsMainFrame(const WebKit::WebFrame* frame) {
+bool IsMainFrame(const blink::WebFrame* frame) {
   return !frame->parent();
 }
 
 // Returns whether |net_error| is a DNS-related error (and therefore whether
 // the tab helper should start a DNS probe after receiving it.)
-bool IsDnsError(const WebKit::WebURLError& error) {
+bool IsDnsError(const blink::WebURLError& error) {
   return std::string(error.domain.utf8()) == net::kErrorDomain &&
          (error.reason == net::ERR_NAME_NOT_RESOLVED ||
           error.reason == net::ERR_NAME_RESOLUTION_FAILED);
 }
 
 }  // namespace
 
 NetErrorHelper::NetErrorHelper(RenderView* render_view)
     : RenderViewObserver(render_view),
       last_probe_status_(chrome_common_net::DNS_PROBE_POSSIBLE),
       last_start_was_error_page_(false),
       last_fail_was_dns_error_(false),
       forwarding_probe_results_(false),
       is_failed_post_(false) {
 }
 
 NetErrorHelper::~NetErrorHelper() {
 }
 
-void NetErrorHelper::DidStartProvisionalLoad(WebKit::WebFrame* frame) {
+void NetErrorHelper::DidStartProvisionalLoad(blink::WebFrame* frame) {
   OnStartLoad(IsMainFrame(frame), IsLoadingErrorPage(frame));
 }
 
-void NetErrorHelper::DidFailProvisionalLoad(WebKit::WebFrame* frame,
-                                            const WebKit::WebURLError& error) {
+void NetErrorHelper::DidFailProvisionalLoad(blink::WebFrame* frame,
+                                            const blink::WebURLError& error) {
   const bool main_frame = IsMainFrame(frame);
   const bool dns_error = IsDnsError(error);
 
   OnFailLoad(main_frame, dns_error);
 
   if (main_frame && dns_error) {
     last_error_ = error;
 
-    WebKit::WebDataSource* data_source = frame->provisionalDataSource();
-    const WebKit::WebURLRequest& failed_request = data_source->request();
+    blink::WebDataSource* data_source = frame->provisionalDataSource();
+    const blink::WebURLRequest& failed_request = data_source->request();
     is_failed_post_ = EqualsASCII(failed_request.httpMethod(), "POST");
   }
 }
 
-void NetErrorHelper::DidCommitProvisionalLoad(WebKit::WebFrame* frame,
+void NetErrorHelper::DidCommitProvisionalLoad(blink::WebFrame* frame,
                                               bool is_new_navigation) {
   OnCommitLoad(IsMainFrame(frame));
 }
 
-void NetErrorHelper::DidFinishLoad(WebKit::WebFrame* frame) {
+void NetErrorHelper::DidFinishLoad(blink::WebFrame* frame) {
   OnFinishLoad(IsMainFrame(frame));
 }
 
 void NetErrorHelper::OnStartLoad(bool is_main_frame, bool is_error_page) {
   DVLOG(1) << "OnStartLoad(is_main_frame=" << is_main_frame
            << ", is_error_page=" << is_error_page << ")";
   if (!is_main_frame)
     return;
 
   last_start_was_error_page_ = is_error_page;
@@ skipping 53 matching lines @@
   IPC_BEGIN_MESSAGE_MAP(NetErrorHelper, message)
     IPC_MESSAGE_HANDLER(ChromeViewMsg_NetErrorInfo, OnNetErrorInfo)
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
 
   return handled;
 }
 
 // static
 bool NetErrorHelper::GetErrorStringsForDnsProbe(
-    WebKit::WebFrame* frame,
-    const WebKit::WebURLError& error,
+    blink::WebFrame* frame,
+    const blink::WebURLError& error,
     bool is_failed_post,
     const std::string& locale,
     const std::string& accept_languages,
     base::DictionaryValue* error_strings) {
   if (!IsMainFrame(frame))
     return false;
 
   if (!IsDnsError(error))
     return false;
 
@@ skipping 21 matching lines @@
 
   last_probe_status_ = status;
 
   if (forwarding_probe_results_)
     UpdateErrorPage();
 }
 
 void NetErrorHelper::UpdateErrorPage() {
   DCHECK(forwarding_probe_results_);
 
-  WebKit::WebURLError error = GetUpdatedError();
+  blink::WebURLError error = GetUpdatedError();
   base::DictionaryValue error_strings;
   LocalizedError::GetStrings(error.reason,
                              error.domain.utf8(),
                              error.unreachableURL,
                              is_failed_post_,
                              RenderThread::Get()->GetLocale(),
                              render_view()->GetAcceptLanguages(),
                              &error_strings);
 
   std::string json;
@@ skipping 12 matching lines @@
   DVLOG(2) << "New strings: " << js;
 
   string16 frame_xpath;
   render_view()->EvaluateScript(frame_xpath, js16, 0, false);
 
   UMA_HISTOGRAM_ENUMERATION("DnsProbe.ErrorPageUpdateStatus",
                             last_probe_status_,
                             chrome_common_net::DNS_PROBE_MAX);
 }
 
-WebKit::WebURLError NetErrorHelper::GetUpdatedError() const {
+blink::WebURLError NetErrorHelper::GetUpdatedError() const {
   // If a probe didn't run or wasn't conclusive, restore the original error.
   if (last_probe_status_ == chrome_common_net::DNS_PROBE_NOT_RUN ||
       last_probe_status_ ==
           chrome_common_net::DNS_PROBE_FINISHED_INCONCLUSIVE) {
     return last_error_;
   }
 
-  WebKit::WebURLError error;
-  error.domain = WebKit::WebString::fromUTF8(
+  blink::WebURLError error;
+  error.domain = blink::WebString::fromUTF8(
       chrome_common_net::kDnsProbeErrorDomain);
   error.reason = last_probe_status_;
   error.unreachableURL = last_error_.unreachableURL;
 
   return error;
 }