Rename WebKit namespace to blink (part 5)

android_webview/renderer/aw_render_view_ext.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 "android_webview/renderer/aw_render_view_ext.h"
 
 #include <string>
 
 #include "android_webview/common/aw_hit_test_data.h"
 #include "android_webview/common/render_view_messages.h"
@@ skipping 19 matching lines @@
 #include "third_party/WebKit/public/web/WebNodeList.h"
 #include "third_party/WebKit/public/web/WebSecurityOrigin.h"
 #include "third_party/WebKit/public/web/WebView.h"
 #include "url/url_canon.h"
 #include "url/url_util.h"
 
 namespace android_webview {
 
 namespace {
 
-bool AllowMixedContent(const WebKit::WebURL& url) {
+bool AllowMixedContent(const blink::WebURL& url) {
   // We treat non-standard schemes as "secure" in the WebView to allow them to
   // be used for request interception.
   // TODO(benm): Tighten this restriction by requiring embedders to register
   // their custom schemes? See b/9420953.
   GURL gurl(url);
   return !gurl.IsStandard();
 }
 
-GURL GetAbsoluteUrl(const WebKit::WebNode& node, const string16& url_fragment) {
+GURL GetAbsoluteUrl(const blink::WebNode& node, const string16& url_fragment) {
   return GURL(node.document().completeURL(url_fragment));
 }
 
-string16 GetHref(const WebKit::WebElement& element) {
+string16 GetHref(const blink::WebElement& element) {
   // Get the actual 'href' attribute, which might relative if valid or can
   // possibly contain garbage otherwise, so not using absoluteLinkURL here.
   return element.getAttribute("href");
 }
 
-GURL GetAbsoluteSrcUrl(const WebKit::WebElement& element) {
+GURL GetAbsoluteSrcUrl(const blink::WebElement& element) {
   if (element.isNull())
     return GURL();
   return GetAbsoluteUrl(element, element.getAttribute("src"));
 }
 
-WebKit::WebNode GetImgChild(const WebKit::WebNode& node) {
+blink::WebNode GetImgChild(const blink::WebNode& node) {
   // This implementation is incomplete (for example if is an area tag) but
   // matches the original WebViewClassic implementation.
 
-  WebKit::WebNodeList list = node.getElementsByTagName("img");
+  blink::WebNodeList list = node.getElementsByTagName("img");
   if (list.length() > 0)
     return list.item(0);
-  return WebKit::WebNode();
+  return blink::WebNode();
 }
 
 bool RemovePrefixAndAssignIfMatches(const base::StringPiece& prefix,
                                     const GURL& url,
                                     std::string* dest) {
   const base::StringPiece spec(url.possibly_invalid_spec());
 
   if (spec.starts_with(prefix)) {
     url_canon::RawCanonOutputW<1024> output;
     url_util::DecodeURLEscapeSequences(spec.data() + prefix.length(),
@@ skipping 85 matching lines @@
     IPC_MESSAGE_HANDLER(AwViewMsg_SetFixedLayoutSize, OnSetFixedLayoutSize)
     IPC_MESSAGE_HANDLER(AwViewMsg_SetBackgroundColor, OnSetBackgroundColor)
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
   return handled;
 }
 
 void AwRenderViewExt::OnDocumentHasImagesRequest(int id) {
   bool hasImages = false;
   if (render_view()) {
-    WebKit::WebView* webview = render_view()->GetWebView();
+    blink::WebView* webview = render_view()->GetWebView();
     if (webview) {
-      WebKit::WebVector<WebKit::WebElement> images;
+      blink::WebVector<blink::WebElement> images;
       webview->mainFrame()->document().images(images);
       hasImages = !images.isEmpty();
     }
   }
   Send(new AwViewHostMsg_DocumentHasImagesResponse(routing_id(), id,
                                                    hasImages));
 }
 
 bool AwRenderViewExt::allowDisplayingInsecureContent(
-      WebKit::WebFrame* frame,
+      blink::WebFrame* frame,
       bool enabled_per_settings,
-      const WebKit::WebSecurityOrigin& origin,
-      const WebKit::WebURL& url) {
+      const blink::WebSecurityOrigin& origin,
+      const blink::WebURL& url) {
   return enabled_per_settings ? true : AllowMixedContent(url);
 }
 
 bool AwRenderViewExt::allowRunningInsecureContent(
-      WebKit::WebFrame* frame,
+      blink::WebFrame* frame,
       bool enabled_per_settings,
-      const WebKit::WebSecurityOrigin& origin,
-      const WebKit::WebURL& url) {
+      const blink::WebSecurityOrigin& origin,
+      const blink::WebURL& url) {
   return enabled_per_settings ? true : AllowMixedContent(url);
 }
 
-void AwRenderViewExt::DidCommitProvisionalLoad(WebKit::WebFrame* frame,
+void AwRenderViewExt::DidCommitProvisionalLoad(blink::WebFrame* frame,
                                                bool is_new_navigation) {
   content::DocumentState* document_state =
       content::DocumentState::FromDataSource(frame->dataSource());
   if (document_state->can_load_local_resources()) {
-    WebKit::WebSecurityOrigin origin = frame->document().securityOrigin();
+    blink::WebSecurityOrigin origin = frame->document().securityOrigin();
     origin.grantLoadLocalResources();
   }
 }
 
 void AwRenderViewExt::DidCommitCompositorFrame() {
   UpdatePageScaleFactor();
 }
 
 void AwRenderViewExt::DidUpdateLayout() {
   if (check_contents_size_timer_.IsRunning())
@@ skipping 11 matching lines @@
                                                   page_scale_factor_));
   }
 }
 
 void AwRenderViewExt::CheckContentsSize() {
   if (!render_view()->GetWebView())
     return;
 
   gfx::Size contents_size;
 
-  WebKit::WebFrame* main_frame = render_view()->GetWebView()->mainFrame();
+  blink::WebFrame* main_frame = render_view()->GetWebView()->mainFrame();
   if (main_frame)
     contents_size = main_frame->contentsSize();
 
   // Fall back to contentsPreferredMinimumSize if the mainFrame is reporting a
   // 0x0 size (this happens during initial load).
   if (contents_size.IsEmpty()) {
     contents_size = render_view()->GetWebView()->contentsPreferredMinimumSize();
   }
 
   if (contents_size == last_sent_contents_size_)
     return;
 
   last_sent_contents_size_ = contents_size;
   Send(new AwViewHostMsg_OnContentsSizeChanged(routing_id(), contents_size));
 }
 
 void AwRenderViewExt::Navigate(const GURL& url) {
   // Navigate is called only on NEW navigations, so WebImageCache won't be freed
   // when the user just clicks on links, but only when a navigation is started,
   // for instance via loadUrl. A better approach would be clearing the cache on
   // cross-site boundaries, however this would require too many changes both on
   // the browser side (in RenderViewHostManger), to the IPCmessages and to the
   // RenderViewObserver. Thus, clearing decoding image cache on Navigate, seems
   // a more acceptable compromise.
-  WebKit::WebImageCache::clear();
+  blink::WebImageCache::clear();
 }
 
-void AwRenderViewExt::FocusedNodeChanged(const WebKit::WebNode& node) {
+void AwRenderViewExt::FocusedNodeChanged(const blink::WebNode& node) {
   if (node.isNull() || !node.isElementNode() || !render_view())
     return;
 
   // Note: element is not const due to innerText() is not const.
-  WebKit::WebElement element = node.toConst<WebKit::WebElement>();
+  blink::WebElement element = node.toConst<blink::WebElement>();
   AwHitTestData data;
 
   data.href = GetHref(element);
   data.anchor_text = element.innerText();
 
   GURL absolute_link_url;
   if (node.isLink())
     absolute_link_url = GetAbsoluteUrl(node, data.href);
 
   GURL absolute_image_url;
-  const WebKit::WebNode child_img = GetImgChild(node);
+  const blink::WebNode child_img = GetImgChild(node);
   if (!child_img.isNull() && child_img.isElementNode()) {
     absolute_image_url =
-        GetAbsoluteSrcUrl(child_img.toConst<WebKit::WebElement>());
+        GetAbsoluteSrcUrl(child_img.toConst<blink::WebElement>());
   }
 
   PopulateHitTestData(absolute_link_url,
                       absolute_image_url,
                       render_view()->IsEditableNode(node),
                       &data);
   Send(new AwViewHostMsg_UpdateHitTestData(routing_id(), data));
 }
 
 void AwRenderViewExt::OnDoHitTest(int view_x, int view_y) {
   if (!render_view() || !render_view()->GetWebView())
     return;
 
-  const WebKit::WebHitTestResult result =
+  const blink::WebHitTestResult result =
       render_view()->GetWebView()->hitTestResultAt(
-          WebKit::WebPoint(view_x, view_y));
+          blink::WebPoint(view_x, view_y));
   AwHitTestData data;
 
   if (!result.urlElement().isNull()) {
     data.anchor_text = result.urlElement().innerText();
     data.href = GetHref(result.urlElement());
   }
 
   PopulateHitTestData(result.absoluteLinkURL(),
                       result.absoluteImageURL(),
                       result.isContentEditable(),
@@ skipping 28 matching lines @@
   render_view()->GetWebView()->setFixedLayoutSize(size);
 }
 
 void AwRenderViewExt::OnSetBackgroundColor(SkColor c) {
   if (!render_view() || !render_view()->GetWebView())
     return;
   render_view()->GetWebView()->setBaseBackgroundColor(c);
 }
 
 }  // namespace android_webview