Rename WebKit namespace to blink (part 3)

content/renderer/render_view_browsertest.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 "base/basictypes.h"
 
 #include "base/memory/shared_memory.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/win/windows_version.h"
@@ skipping 39 matching lines @@
 #include "ui/events/event.h"
 #endif
 
 #if defined(USE_AURA) && defined(USE_X11)
 #include <X11/Xlib.h>
 #include "ui/events/event_constants.h"
 #include "ui/events/keycodes/keyboard_code_conversion.h"
 #include "ui/events/x/events_x_utils.h"
 #endif
 
-using WebKit::WebFrame;
-using WebKit::WebInputEvent;
-using WebKit::WebMouseEvent;
-using WebKit::WebRuntimeFeatures;
-using WebKit::WebString;
-using WebKit::WebTextDirection;
-using WebKit::WebURLError;
+using blink::WebFrame;
+using blink::WebInputEvent;
+using blink::WebMouseEvent;
+using blink::WebRuntimeFeatures;
+using blink::WebString;
+using blink::WebTextDirection;
+using blink::WebURLError;
 
 namespace content  {
 
 namespace {
 
 #if defined(USE_AURA) && defined(USE_X11)
 // Converts MockKeyboard::Modifiers to ui::EventFlags.
 int ConvertMockKeyboardModifier(MockKeyboard::Modifiers modifiers) {
   static struct ModifierMap {
     MockKeyboard::Modifiers src;
@@ skipping 163 matching lines @@
     guint32 unicode_key = 0;
     for (size_t i = 0; i < events.size(); ++i) {
       // Only send the up/down events for key press itself (skip the up/down
       // events for the modifier keys).
       if ((i + 1) == (events.size() / 2) || i == (events.size() / 2)) {
         unicode_key = gdk_keyval_to_unicode(events[i]->key.keyval);
         NativeWebKeyboardEvent webkit_event(events[i]);
         SendNativeKeyEvent(webkit_event);
 
         // Need to add a char event after the key down.
-        if (webkit_event.type == WebKit::WebInputEvent::RawKeyDown) {
+        if (webkit_event.type == blink::WebInputEvent::RawKeyDown) {
           NativeWebKeyboardEvent char_event = webkit_event;
-          char_event.type = WebKit::WebInputEvent::Char;
+          char_event.type = blink::WebInputEvent::Char;
           char_event.skip_in_browser = true;
           SendNativeKeyEvent(char_event);
         }
       }
       gdk_event_free(events[i]);
     }
 
     output->assign(1, static_cast<char16>(unicode_key));
     return 1;
 #else
@@ skipping 52 matching lines @@
       render_thread_->sink().GetUniqueMessageMatching(
           ViewHostMsg_FrameNavigate::ID);
   EXPECT_TRUE(frame_navigate_msg);
 
   ViewHostMsg_FrameNavigate::Param host_nav_params;
   ViewHostMsg_FrameNavigate::Read(frame_navigate_msg, &host_nav_params);
   EXPECT_TRUE(host_nav_params.a.is_post);
 
   // Check post data sent to browser matches
   EXPECT_TRUE(host_nav_params.a.page_state.IsValid());
-  const WebKit::WebHistoryItem item = PageStateToHistoryItem(
+  const blink::WebHistoryItem item = PageStateToHistoryItem(
       host_nav_params.a.page_state);
-  WebKit::WebHTTPBody body = item.httpBody();
-  WebKit::WebHTTPBody::Element element;
+  blink::WebHTTPBody body = item.httpBody();
+  blink::WebHTTPBody::Element element;
   bool successful = body.elementAt(0, element);
   EXPECT_TRUE(successful);
-  EXPECT_EQ(WebKit::WebHTTPBody::Element::TypeData, element.type);
+  EXPECT_EQ(blink::WebHTTPBody::Element::TypeData, element.type);
   EXPECT_EQ(length, element.data.size());
   EXPECT_EQ(0, memcmp(raw_data, element.data.data(), length));
 }
 
 TEST_F(RenderViewImplTest, DecideNavigationPolicy) {
   WebUITestWebUIControllerFactory factory;
   WebUIControllerFactory::RegisterFactory(&factory);
 
   DocumentState state;
   state.set_navigation_state(NavigationState::CreateContentInitiated());
 
   // Navigations to normal HTTP URLs can be handled locally.
-  WebKit::WebURLRequest request(GURL("http://foo.com"));
-  WebKit::WebNavigationPolicy policy = view()->decidePolicyForNavigation(
+  blink::WebURLRequest request(GURL("http://foo.com"));
+  blink::WebNavigationPolicy policy = view()->decidePolicyForNavigation(
       GetMainFrame(),
       &state,
       request,
-      WebKit::WebNavigationTypeLinkClicked,
-      WebKit::WebNavigationPolicyCurrentTab,
+      blink::WebNavigationTypeLinkClicked,
+      blink::WebNavigationPolicyCurrentTab,
       false);
-  EXPECT_EQ(WebKit::WebNavigationPolicyCurrentTab, policy);
+  EXPECT_EQ(blink::WebNavigationPolicyCurrentTab, policy);
 
   // Verify that form posts to WebUI URLs will be sent to the browser process.
-  WebKit::WebURLRequest form_request(GURL("chrome://foo"));
+  blink::WebURLRequest form_request(GURL("chrome://foo"));
   form_request.setHTTPMethod("POST");
   policy = view()->decidePolicyForNavigation(
       GetMainFrame(),
       &state,
       form_request,
-      WebKit::WebNavigationTypeFormSubmitted,
-      WebKit::WebNavigationPolicyCurrentTab,
+      blink::WebNavigationTypeFormSubmitted,
+      blink::WebNavigationPolicyCurrentTab,
       false);
-  EXPECT_EQ(WebKit::WebNavigationPolicyIgnore, policy);
+  EXPECT_EQ(blink::WebNavigationPolicyIgnore, policy);
 
   // Verify that popup links to WebUI URLs also are sent to browser.
-  WebKit::WebURLRequest popup_request(GURL("chrome://foo"));
+  blink::WebURLRequest popup_request(GURL("chrome://foo"));
   policy = view()->decidePolicyForNavigation(
       GetMainFrame(),
       &state,
       popup_request,
-      WebKit::WebNavigationTypeLinkClicked,
-      WebKit::WebNavigationPolicyNewForegroundTab,
+      blink::WebNavigationTypeLinkClicked,
+      blink::WebNavigationPolicyNewForegroundTab,
       false);
-  EXPECT_EQ(WebKit::WebNavigationPolicyIgnore, policy);
+  EXPECT_EQ(blink::WebNavigationPolicyIgnore, policy);
 }
 
 TEST_F(RenderViewImplTest, DecideNavigationPolicyForWebUI) {
   // Enable bindings to simulate a WebUI view.
   view()->OnAllowBindings(BINDINGS_POLICY_WEB_UI);
 
   DocumentState state;
   state.set_navigation_state(NavigationState::CreateContentInitiated());
 
   // Navigations to normal HTTP URLs will be sent to browser process.
-  WebKit::WebURLRequest request(GURL("http://foo.com"));
-  WebKit::WebNavigationPolicy policy = view()->decidePolicyForNavigation(
+  blink::WebURLRequest request(GURL("http://foo.com"));
+  blink::WebNavigationPolicy policy = view()->decidePolicyForNavigation(
       GetMainFrame(),
       &state,
       request,
-      WebKit::WebNavigationTypeLinkClicked,
-      WebKit::WebNavigationPolicyCurrentTab,
+      blink::WebNavigationTypeLinkClicked,
+      blink::WebNavigationPolicyCurrentTab,
       false);
-  EXPECT_EQ(WebKit::WebNavigationPolicyIgnore, policy);
+  EXPECT_EQ(blink::WebNavigationPolicyIgnore, policy);
 
   // Navigations to WebUI URLs will also be sent to browser process.
-  WebKit::WebURLRequest webui_request(GURL("chrome://foo"));
+  blink::WebURLRequest webui_request(GURL("chrome://foo"));
   policy = view()->decidePolicyForNavigation(
       GetMainFrame(),
       &state,
       webui_request,
-      WebKit::WebNavigationTypeLinkClicked,
-      WebKit::WebNavigationPolicyCurrentTab,
+      blink::WebNavigationTypeLinkClicked,
+      blink::WebNavigationPolicyCurrentTab,
       false);
-  EXPECT_EQ(WebKit::WebNavigationPolicyIgnore, policy);
+  EXPECT_EQ(blink::WebNavigationPolicyIgnore, policy);
 
   // Verify that form posts to data URLs will be sent to the browser process.
-  WebKit::WebURLRequest data_request(GURL("data:text/html,foo"));
+  blink::WebURLRequest data_request(GURL("data:text/html,foo"));
   data_request.setHTTPMethod("POST");
   policy = view()->decidePolicyForNavigation(
       GetMainFrame(),
       &state,
       data_request,
-      WebKit::WebNavigationTypeFormSubmitted,
-      WebKit::WebNavigationPolicyCurrentTab,
+      blink::WebNavigationTypeFormSubmitted,
+      blink::WebNavigationPolicyCurrentTab,
       false);
-  EXPECT_EQ(WebKit::WebNavigationPolicyIgnore, policy);
+  EXPECT_EQ(blink::WebNavigationPolicyIgnore, policy);
 
   // Verify that a popup that creates a view first and then navigates to a
   // normal HTTP URL will be sent to the browser process, even though the
   // new view does not have any enabled_bindings_.
-  WebKit::WebURLRequest popup_request(GURL("http://foo.com"));
-  WebKit::WebView* new_web_view = view()->createView(
-      GetMainFrame(), popup_request, WebKit::WebWindowFeatures(), "foo",
-      WebKit::WebNavigationPolicyNewForegroundTab);
+  blink::WebURLRequest popup_request(GURL("http://foo.com"));
+  blink::WebView* new_web_view = view()->createView(
+      GetMainFrame(), popup_request, blink::WebWindowFeatures(), "foo",
+      blink::WebNavigationPolicyNewForegroundTab);
   RenderViewImpl* new_view = RenderViewImpl::FromWebView(new_web_view);
   policy = new_view->decidePolicyForNavigation(
       new_web_view->mainFrame(),
       &state,
       popup_request,
-      WebKit::WebNavigationTypeLinkClicked,
-      WebKit::WebNavigationPolicyNewForegroundTab,
+      blink::WebNavigationTypeLinkClicked,
+      blink::WebNavigationPolicyNewForegroundTab,
       false);
-  EXPECT_EQ(WebKit::WebNavigationPolicyIgnore, policy);
+  EXPECT_EQ(blink::WebNavigationPolicyIgnore, policy);
 
   // Clean up after the new view so we don't leak it.
   new_view->Close();
   new_view->Release();
 }
 
 // Ensure the RenderViewImpl sends an ACK to a SwapOut request, even if it is
 // already swapped out.  http://crbug.com/93427.
 TEST_F(RenderViewImplTest, SendSwapOutACK) {
   LoadHTML("<div>Page A</div>");
@@ skipping 555 matching lines @@
         break;
 
       case IME_SETFOCUS:
         // Update the window focus.
         view()->OnSetFocus(ime_message->enable);
         break;
 
       case IME_SETCOMPOSITION:
         view()->OnImeSetComposition(
             WideToUTF16Hack(ime_message->ime_string),
-            std::vector<WebKit::WebCompositionUnderline>(),
+            std::vector<blink::WebCompositionUnderline>(),
             ime_message->selection_start,
             ime_message->selection_end);
         break;
 
       case IME_CONFIRMCOMPOSITION:
         view()->OnImeConfirmComposition(
             WideToUTF16Hack(ime_message->ime_string),
             gfx::Range::InvalidRange(),
             false);
         break;
 
       case IME_CANCELCOMPOSITION:
         view()->OnImeSetComposition(
             string16(),
-            std::vector<WebKit::WebCompositionUnderline>(),
+            std::vector<blink::WebCompositionUnderline>(),
             0, 0);
         break;
     }
 
     // Update the status of our IME back-end.
     // TODO(hbono): we should verify messages to be sent from the back-end.
     view()->UpdateTextInputType();
     ProcessPendingMessages();
     render_thread_->sink().ClearMessages();
 
@@ skipping 23 matching lines @@
            "<textarea id=\"test\"></textarea>"
            "<div id=\"result\" contenteditable=\"true\"></div>"
            "</body>"
            "</html>");
   render_thread_->sink().ClearMessages();
 
   static const struct {
     WebTextDirection direction;
     const wchar_t* expected_result;
   } kTextDirection[] = {
-    { WebKit::WebTextDirectionRightToLeft, L"\x000A" L"rtl,rtl" },
-    { WebKit::WebTextDirectionLeftToRight, L"\x000A" L"ltr,ltr" },
+    { blink::WebTextDirectionRightToLeft, L"\x000A" L"rtl,rtl" },
+    { blink::WebTextDirectionLeftToRight, L"\x000A" L"ltr,ltr" },
   };
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(kTextDirection); ++i) {
     // Set the text direction of the <textarea> element.
     ExecuteJavaScript("document.getElementById('test').focus();");
     view()->OnSetTextDirection(kTextDirection[i].direction);
 
     // Write the values of its DOM 'dir' attribute and its CSS 'direction'
     // property to the <div> element.
     ExecuteJavaScript("var result = document.getElementById('result');"
                       "var node = document.getElementById('test');"
@@ skipping 435 matching lines @@
 
   // A cancellation occurred.
   view()->didFailProvisionalLoad(web_frame, error);
   // Frame should stay in view-source mode.
   EXPECT_TRUE(web_frame->isViewSourceModeEnabled());
 }
 
 // Regression test for http://crbug.com/41562
 TEST_F(RenderViewImplTest, UpdateTargetURLWithInvalidURL) {
   const GURL invalid_gurl("http://");
-  view()->setMouseOverURL(WebKit::WebURL(invalid_gurl));
+  view()->setMouseOverURL(blink::WebURL(invalid_gurl));
   EXPECT_EQ(invalid_gurl, view()->target_url_);
 }
 
 TEST_F(RenderViewImplTest, SetHistoryLengthAndPrune) {
   int expected_page_id = -1;
 
   // No history to merge and no committed pages.
   view()->OnSetHistoryLengthAndPrune(0, -1);
   EXPECT_EQ(0, view()->history_list_length_);
   EXPECT_EQ(-1, view()->history_list_offset_);
@@ skipping 168 matching lines @@
   // Now simulate the corresponding up event which should display the menu
   mouse_event.type = WebInputEvent::MouseUp;
   SendWebMouseEvent(mouse_event);
 
   EXPECT_TRUE(render_thread_->sink().GetUniqueMessageMatching(
       ViewHostMsg_ContextMenu::ID));
 }
 
 TEST_F(RenderViewImplTest, TestBackForward) {
   LoadHTML("<div id=pagename>Page A</div>");
-  WebKit::WebHistoryItem page_a_item = GetMainFrame()->currentHistoryItem();
+  blink::WebHistoryItem page_a_item = GetMainFrame()->currentHistoryItem();
   int was_page_a = -1;
   string16 check_page_a =
       ASCIIToUTF16(
           "Number(document.getElementById('pagename').innerHTML == 'Page A')");
   EXPECT_TRUE(ExecuteJavaScriptAndReturnIntValue(check_page_a, &was_page_a));
   EXPECT_EQ(1, was_page_a);
 
   LoadHTML("<div id=pagename>Page B</div>");
   int was_page_b = -1;
   string16 check_page_b =
       ASCIIToUTF16(
           "Number(document.getElementById('pagename').innerHTML == 'Page B')");
   EXPECT_TRUE(ExecuteJavaScriptAndReturnIntValue(check_page_b, &was_page_b));
   EXPECT_EQ(1, was_page_b);
 
   LoadHTML("<div id=pagename>Page C</div>");
   int was_page_c = -1;
   string16 check_page_c =
       ASCIIToUTF16(
           "Number(document.getElementById('pagename').innerHTML == 'Page C')");
   EXPECT_TRUE(ExecuteJavaScriptAndReturnIntValue(check_page_c, &was_page_c));
   EXPECT_EQ(1, was_page_b);
 
-  WebKit::WebHistoryItem forward_item = GetMainFrame()->currentHistoryItem();
+  blink::WebHistoryItem forward_item = GetMainFrame()->currentHistoryItem();
   GoBack(GetMainFrame()->previousHistoryItem());
   EXPECT_TRUE(ExecuteJavaScriptAndReturnIntValue(check_page_b, &was_page_b));
   EXPECT_EQ(1, was_page_b);
 
   GoForward(forward_item);
   EXPECT_TRUE(ExecuteJavaScriptAndReturnIntValue(check_page_c, &was_page_c));
   EXPECT_EQ(1, was_page_c);
 
   GoBack(GetMainFrame()->previousHistoryItem());
   EXPECT_TRUE(ExecuteJavaScriptAndReturnIntValue(check_page_b, &was_page_b));
@@ skipping 15 matching lines @@
 #if defined(OS_WIN)
   // http://crbug.com/304193
   if (base::win::GetVersion() < base::win::VERSION_VISTA)
     return;
 #endif
 
   LoadHTML("<textarea id=\"test\"></textarea>");
   ExecuteJavaScript("document.getElementById('test').focus();");
 
   const string16 empty_string = UTF8ToUTF16("");
-  const std::vector<WebKit::WebCompositionUnderline> empty_underline;
+  const std::vector<blink::WebCompositionUnderline> empty_underline;
   std::vector<gfx::Rect> bounds;
   view()->OnSetFocus(true);
   view()->OnSetInputMethodActive(true);
 
   // ASCII composition
   const string16 ascii_composition = UTF8ToUTF16("aiueo");
   view()->OnImeSetComposition(ascii_composition, empty_underline, 0, 0);
   view()->GetCompositionCharacterBounds(&bounds);
   ASSERT_EQ(ascii_composition.size(), bounds.size());
   for (size_t i = 0; i < bounds.size(); ++i)
@@ skipping 81 matching lines @@
   // Load an HTML page consisting of an input field.
   LoadHTML("<html>"
            "<head>"
            "</head>"
            "<body>"
            "<input id=\"test1\" value=\"some test text hello\"></input>"
            "</body>"
            "</html>");
   ExecuteJavaScript("document.getElementById('test1').focus();");
   view()->OnSetEditableSelectionOffsets(4, 8);
-  const std::vector<WebKit::WebCompositionUnderline> empty_underline;
+  const std::vector<blink::WebCompositionUnderline> empty_underline;
   view()->OnSetCompositionFromExistingText(7, 10, empty_underline);
-  WebKit::WebTextInputInfo info = view()->webview()->textInputInfo();
+  blink::WebTextInputInfo info = view()->webview()->textInputInfo();
   EXPECT_EQ(4, info.selectionStart);
   EXPECT_EQ(8, info.selectionEnd);
   EXPECT_EQ(7, info.compositionStart);
   EXPECT_EQ(10, info.compositionEnd);
   view()->OnUnselect();
   info = view()->webview()->textInputInfo();
   EXPECT_EQ(0, info.selectionStart);
   EXPECT_EQ(0, info.selectionEnd);
 }
 
 
 TEST_F(RenderViewImplTest, OnExtendSelectionAndDelete) {
   // Load an HTML page consisting of an input field.
   LoadHTML("<html>"
            "<head>"
            "</head>"
            "<body>"
            "<input id=\"test1\" value=\"abcdefghijklmnopqrstuvwxyz\"></input>"
            "</body>"
            "</html>");
   ExecuteJavaScript("document.getElementById('test1').focus();");
   view()->OnSetEditableSelectionOffsets(10, 10);
   view()->OnExtendSelectionAndDelete(3, 4);
-  WebKit::WebTextInputInfo info = view()->webview()->textInputInfo();
+  blink::WebTextInputInfo info = view()->webview()->textInputInfo();
   EXPECT_EQ("abcdefgopqrstuvwxyz", info.value);
   EXPECT_EQ(7, info.selectionStart);
   EXPECT_EQ(7, info.selectionEnd);
   view()->OnSetEditableSelectionOffsets(4, 8);
   view()->OnExtendSelectionAndDelete(2, 5);
   info = view()->webview()->textInputInfo();
   EXPECT_EQ("abuvwxyz", info.value);
   EXPECT_EQ(2, info.selectionStart);
   EXPECT_EQ(2, info.selectionEnd);
 }
@@ skipping 30 matching lines @@
   EXPECT_TRUE(view()->main_render_frame_.get());
 }
 
 TEST_F(RenderViewImplTest, GetSSLStatusOfFrame) {
   LoadHTML("<!DOCTYPE html><html><body></body></html>");
 
   WebFrame* frame = GetMainFrame();
   SSLStatus ssl_status = view()->GetSSLStatusOfFrame(frame);
   EXPECT_FALSE(net::IsCertStatusError(ssl_status.cert_status));
 
-  const_cast<WebKit::WebURLResponse&>(frame->dataSource()->response()).
+  const_cast<blink::WebURLResponse&>(frame->dataSource()->response()).
       setSecurityInfo(
           SerializeSecurityInfo(0, net::CERT_STATUS_ALL_ERRORS, 0, 0));
   ssl_status = view()->GetSSLStatusOfFrame(frame);
   EXPECT_TRUE(net::IsCertStatusError(ssl_status.cert_status));
 }
 
 class SuppressErrorPageTest : public RenderViewTest {
  public:
   virtual void SetUp() OVERRIDE {
     SetRendererClientForTesting(&client_);
     RenderViewTest::SetUp();
   }
 
   RenderViewImpl* view() {
     return static_cast<RenderViewImpl*>(view_);
   }
 
  private:
   class TestContentRendererClient : public ContentRendererClient {
    public:
     virtual bool ShouldSuppressErrorPage(const GURL& url) OVERRIDE {
       return url == GURL("http://example.com/suppress");
     }
 
     virtual void GetNavigationErrorStrings(
-        WebKit::WebFrame* frame,
-        const WebKit::WebURLRequest& failed_request,
-        const WebKit::WebURLError& error,
+        blink::WebFrame* frame,
+        const blink::WebURLRequest& failed_request,
+        const blink::WebURLError& error,
         const std::string& accept_languages,
         std::string* error_html,
         string16* error_description) OVERRIDE {
       if (error_html)
         *error_html = "A suffusion of yellow.";
     }
   };
 
   TestContentRendererClient client_;
 };
@@ skipping 50 matching lines @@
 
   // An error occurred.
   view()->didFailProvisionalLoad(web_frame, error);
   ProcessPendingMessages();
   const int kMaxOutputCharacters = 22;
   EXPECT_EQ("A suffusion of yellow.",
             UTF16ToASCII(web_frame->contentAsText(kMaxOutputCharacters)));
 }
 
 }  // namespace content