Rename WebKit namespace to blink

Source/testing/runner/WebTestProxy.cpp

 /*
  * Copyright (C) 2012 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 54 matching lines @@
 #include "public/web/WebPrintParams.h"
 #include "public/web/WebRange.h"
 #include "public/web/WebScriptController.h"
 #include "public/web/WebUserGestureIndicator.h"
 #include "public/web/WebView.h"
 
 // FIXME: Including platform_canvas.h here is a layering violation.
 #include <cctype>
 #include "skia/ext/platform_canvas.h"
 
-using namespace WebKit;
+using namespace blink;
 using namespace std;
 
 namespace WebTestRunner {
 
 namespace {
 
 class HostMethodTask : public WebMethodTask<WebTestProxyBase> {
 public:
     typedef void (WebTestProxyBase::*CallbackMethodType)();
     HostMethodTask(WebTestProxyBase* object, CallbackMethodType callback)
@@ skipping 39 matching lines @@
     printNodeDescription(delegate, startNode, exception);
     snprintf(buffer, sizeof(buffer), " to %d of ", range.endOffset());
     delegate->printMessage(buffer);
     WebNode endNode = range.endContainer(exception);
     printNodeDescription(delegate, endNode, exception);
 }
 
 string textAffinityDescription(WebTextAffinity affinity)
 {
     switch (affinity) {
-    case WebKit::WebTextAffinityUpstream:
+    case blink::WebTextAffinityUpstream:
         return "NSSelectionAffinityUpstream";
-    case WebKit::WebTextAffinityDownstream:
+    case blink::WebTextAffinityDownstream:
         return "NSSelectionAffinityDownstream";
     }
     return "(UNKNOWN AFFINITY)";
 }
 
 void printFrameDescription(WebTestDelegate* delegate, WebFrame* frame)
 {
     string name8 = frame->uniqueName().utf8();
     if (frame == frame->view()->mainFrame()) {
         if (!name8.length()) {
@@ skipping 116 matching lines @@
 const char* backForwardString = "back/forward";
 const char* reloadString = "reload";
 const char* formResubmittedString = "form resubmitted";
 const char* otherString = "other";
 const char* illegalString = "illegal value";
 
 // Get a debugging string from a WebNavigationType.
 const char* webNavigationTypeToString(WebNavigationType type)
 {
     switch (type) {
-    case WebKit::WebNavigationTypeLinkClicked:
+    case blink::WebNavigationTypeLinkClicked:
         return linkClickedString;
-    case WebKit::WebNavigationTypeFormSubmitted:
+    case blink::WebNavigationTypeFormSubmitted:
         return formSubmittedString;
-    case WebKit::WebNavigationTypeBackForward:
+    case blink::WebNavigationTypeBackForward:
         return backForwardString;
-    case WebKit::WebNavigationTypeReload:
+    case blink::WebNavigationTypeReload:
         return reloadString;
-    case WebKit::WebNavigationTypeFormResubmitted:
+    case blink::WebNavigationTypeFormResubmitted:
         return formResubmittedString;
-    case WebKit::WebNavigationTypeOther:
+    case blink::WebNavigationTypeOther:
         return otherString;
     }
     return illegalString;
 }
 
 string dumpDocumentText(WebFrame* frame)
 {
     // We use the document element's text instead of the body text here because
     // not all documents have a body, such as XML documents.
     WebElement documentElement = frame->document().documentElement();
@@ skipping 220 matching lines @@
 WebSpellCheckClient* WebTestProxyBase::spellCheckClient() const
 {
     return m_spellcheck.get();
 }
 
 WebValidationMessageClient* WebTestProxyBase::validationMessageClient()
 {
     return m_validationMessageClient.get();
 }
 
-WebColorChooser* WebTestProxyBase::createColorChooser(WebColorChooserClient* client, const WebKit::WebColor& color)
+WebColorChooser* WebTestProxyBase::createColorChooser(WebColorChooserClient* client, const blink::WebColor& color)
 {
     // This instance is deleted by WebCore::ColorInputType
     return new MockColorChooser(client, m_delegate, this);
 }
 
-bool WebTestProxyBase::runFileChooser(const WebKit::WebFileChooserParams&, WebKit::WebFileChooserCompletion*)
+bool WebTestProxyBase::runFileChooser(const blink::WebFileChooserParams&, blink::WebFileChooserCompletion*)
 {
     m_delegate->printMessage("Mock: Opening a file chooser.\n");
     // FIXME: Add ability to set file names to a file upload control.
     return false;
 }
 
 string WebTestProxyBase::captureTree(bool debugRenderTree)
 {
     WebScriptController::flushConsoleMessages();
 
@@ skipping 158 matching lines @@
 
 // Paints the entire canvas a semi-transparent black (grayish). This is used
 // by the layout tests in fast/repaint. The alpha value matches upstream.
 void WebTestProxyBase::displayRepaintMask()
 {
     canvas()->drawARGB(167, 0, 0, 0);
 }
 
 void WebTestProxyBase::display()
 {
-    const WebKit::WebSize& size = webWidget()->size();
+    const blink::WebSize& size = webWidget()->size();
     WebRect rect(0, 0, size.width, size.height);
     m_paintRect = rect;
     paintInvalidatedRegion();
     displayRepaintMask();
 }
 
 void WebTestProxyBase::displayInvalidatedRegion()
 {
     paintInvalidatedRegion();
     displayRepaintMask();
@@ skipping 94 matching lines @@
 {
     invalidateAll();
     discardBackingStore();
 }
 
 void WebTestProxyBase::didAutoResize(const WebSize&)
 {
     invalidateAll();
 }
 
-void WebTestProxyBase::postAccessibilityEvent(const WebKit::WebAXObject& obj, WebKit::WebAXEvent event)
+void WebTestProxyBase::postAccessibilityEvent(const blink::WebAXObject& obj, blink::WebAXEvent event)
 {
-    if (event == WebKit::WebAXEventFocus)
+    if (event == blink::WebAXEventFocus)
         m_testInterfaces->accessibilityController()->setFocusedElement(obj);
 
     const char* eventName = 0;
     switch (event) {
-    case WebKit::WebAXEventActiveDescendantChanged:
+    case blink::WebAXEventActiveDescendantChanged:
         eventName = "ActiveDescendantChanged";
         break;
-    case WebKit::WebAXEventAlert:
+    case blink::WebAXEventAlert:
         eventName = "Alert";
         break;
-    case WebKit::WebAXEventAriaAttributeChanged:
+    case blink::WebAXEventAriaAttributeChanged:
         eventName = "AriaAttributeChanged";
         break;
-    case WebKit::WebAXEventAutocorrectionOccured:
+    case blink::WebAXEventAutocorrectionOccured:
         eventName = "AutocorrectionOccured";
         break;
-    case WebKit::WebAXEventBlur:
+    case blink::WebAXEventBlur:
         eventName = "Blur";
         break;
-    case WebKit::WebAXEventCheckedStateChanged:
+    case blink::WebAXEventCheckedStateChanged:
         eventName = "CheckedStateChanged";
         break;
-    case WebKit::WebAXEventChildrenChanged:
+    case blink::WebAXEventChildrenChanged:
         eventName = "ChildrenChanged";
         break;
-    case WebKit::WebAXEventFocus:
+    case blink::WebAXEventFocus:
         eventName = "Focus";
         break;
-    case WebKit::WebAXEventHide:
+    case blink::WebAXEventHide:
         eventName = "Hide";
         break;
-    case WebKit::WebAXEventInvalidStatusChanged:
+    case blink::WebAXEventInvalidStatusChanged:
         eventName = "InvalidStatusChanged";
         break;
-    case WebKit::WebAXEventLayoutComplete:
+    case blink::WebAXEventLayoutComplete:
         eventName = "LayoutComplete";
         break;
-    case WebKit::WebAXEventLiveRegionChanged:
+    case blink::WebAXEventLiveRegionChanged:
         eventName = "LiveRegionChanged";
         break;
-    case WebKit::WebAXEventLoadComplete:
+    case blink::WebAXEventLoadComplete:
         eventName = "LoadComplete";
         break;
-    case WebKit::WebAXEventLocationChanged:
+    case blink::WebAXEventLocationChanged:
         eventName = "LocationChanged";
         break;
-    case WebKit::WebAXEventMenuListItemSelected:
+    case blink::WebAXEventMenuListItemSelected:
         eventName = "MenuListItemSelected";
         break;
-    case WebKit::WebAXEventMenuListValueChanged:
+    case blink::WebAXEventMenuListValueChanged:
         eventName = "MenuListValueChanged";
         break;
-    case WebKit::WebAXEventRowCollapsed:
+    case blink::WebAXEventRowCollapsed:
         eventName = "RowCollapsed";
         break;
-    case WebKit::WebAXEventRowCountChanged:
+    case blink::WebAXEventRowCountChanged:
         eventName = "RowCountChanged";
         break;
-    case WebKit::WebAXEventRowExpanded:
+    case blink::WebAXEventRowExpanded:
         eventName = "RowExpanded";
         break;
-    case WebKit::WebAXEventScrolledToAnchor:
+    case blink::WebAXEventScrolledToAnchor:
         eventName = "ScrolledToAnchor";
         break;
-    case WebKit::WebAXEventSelectedChildrenChanged:
+    case blink::WebAXEventSelectedChildrenChanged:
         eventName = "SelectedChildrenChanged";
         break;
-    case WebKit::WebAXEventSelectedTextChanged:
+    case blink::WebAXEventSelectedTextChanged:
         eventName = "SelectedTextChanged";
         break;
-    case WebKit::WebAXEventShow:
+    case blink::WebAXEventShow:
         eventName = "Show";
         break;
-    case WebKit::WebAXEventTextChanged:
+    case blink::WebAXEventTextChanged:
         eventName = "TextChanged";
         break;
-    case WebKit::WebAXEventTextInserted:
+    case blink::WebAXEventTextInserted:
         eventName = "TextInserted";
         break;
-    case WebKit::WebAXEventTextRemoved:
+    case blink::WebAXEventTextRemoved:
         eventName = "TextRemoved";
         break;
-    case WebKit::WebAXEventValueChanged:
+    case blink::WebAXEventValueChanged:
         eventName = "ValueChanged";
         break;
     }
 
     m_testInterfaces->accessibilityController()->notificationReceived(obj, eventName);
 
     if (m_testInterfaces->accessibilityController()->shouldLogAccessibilityEvents()) {
         string message("AccessibilityNotification - ");
         message += eventName;
 
-        WebKit::WebNode node = obj.node();
+        blink::WebNode node = obj.node();
         if (!node.isNull() && node.isElementNode()) {
-            WebKit::WebElement element = node.to<WebKit::WebElement>();
+            blink::WebElement element = node.to<blink::WebElement>();
             if (element.hasAttribute("id")) {
                 message += " - id:";
                 message += element.getAttribute("id").utf8().data();
             }
         }
 
         m_delegate->printMessage(message + "\n");
     }
 }
 
@@ skipping 258 matching lines @@
     if (m_testInterfaces->testRunner()->shouldDumpFrameLoadCallbacks())
         m_delegate->printMessage("didDetectXSS\n");
 }
 
 void WebTestProxyBase::didDispatchPingLoader(WebFrame*, const WebURL& url)
 {
     if (m_testInterfaces->testRunner()->shouldDumpPingLoaderCallbacks())
         m_delegate->printMessage(string("PingLoader dispatched to '") + URLDescription(url).c_str() + "'.\n");
 }
 
-void WebTestProxyBase::willRequestResource(WebFrame* frame, const WebKit::WebCachedURLRequest& request)
+void WebTestProxyBase::willRequestResource(WebFrame* frame, const blink::WebCachedURLRequest& request)
 {
     if (m_testInterfaces->testRunner()->shouldDumpResourceRequestCallbacks()) {
         printFrameDescription(m_delegate, frame);
         m_delegate->printMessage(string(" - ") + request.initiatorName().utf8().data());
         m_delegate->printMessage(string(" requested '") + URLDescription(request.urlRequest().url()).c_str() + "'\n");
     }
 }
 
 void WebTestProxyBase::didCreateDataSource(WebFrame*, WebDataSource* ds)
 {
     if (!m_testInterfaces->testRunner()->deferMainResourceDataLoad())
         ds->setDeferMainResourceDataLoad(false);
 }
 
-void WebTestProxyBase::willSendRequest(WebFrame*, unsigned identifier, WebKit::WebURLRequest& request, const WebKit::WebURLResponse& redirectResponse)
+void WebTestProxyBase::willSendRequest(WebFrame*, unsigned identifier, blink::WebURLRequest& request, const blink::WebURLResponse& redirectResponse)
 {
     // Need to use GURL for host() and SchemeIs()
     GURL url = request.url();
     string requestURL = url.possibly_invalid_spec();
 
     GURL mainDocumentURL = request.firstPartyForCookies();
 
     if (redirectResponse.isNull() && (m_testInterfaces->testRunner()->shouldDumpResourceLoadCallbacks() || m_testInterfaces->testRunner()->shouldDumpResourcePriorities())) {
         BLINK_ASSERT(m_resourceIdentifierMap.find(identifier) == m_resourceIdentifierMap.end());
         m_resourceIdentifierMap[identifier] = descriptionSuitableForTestResult(requestURL);
@@ skipping 36 matching lines @@
             m_delegate->printMessage(string("Blocked access to external URL ") + requestURL + "\n");
             blockRequest(request);
             return;
         }
     }
 
     // Set the new substituted URL.
     request.setURL(m_delegate->rewriteLayoutTestsURL(request.url().spec()));
 }
 
-void WebTestProxyBase::didReceiveResponse(WebFrame*, unsigned identifier, const WebKit::WebURLResponse& response)
+void WebTestProxyBase::didReceiveResponse(WebFrame*, unsigned identifier, const blink::WebURLResponse& response)
 {
     if (m_testInterfaces->testRunner()->shouldDumpResourceLoadCallbacks()) {
         if (m_resourceIdentifierMap.find(identifier) == m_resourceIdentifierMap.end())
             m_delegate->printMessage("<unknown>");
         else
             m_delegate->printMessage(m_resourceIdentifierMap[identifier]);
         m_delegate->printMessage(" - didReceiveResponse ");
         printResponseDescription(m_delegate, response);
         m_delegate->printMessage("\n");
     }
     if (m_testInterfaces->testRunner()->shouldDumpResourceResponseMIMETypes()) {
         GURL url = response.url();
         WebString mimeType = response.mimeType();
         m_delegate->printMessage(url.ExtractFileName());
         m_delegate->printMessage(" has MIME type ");
         // Simulate NSURLResponse's mapping of empty/unknown MIME types to application/octet-stream
         m_delegate->printMessage(mimeType.isEmpty() ? "application/octet-stream" : mimeType.utf8().data());
         m_delegate->printMessage("\n");
     }
 }
 
-void WebTestProxyBase::didChangeResourcePriority(WebFrame*, unsigned identifier, const WebKit::WebURLRequest::Priority& priority)
+void WebTestProxyBase::didChangeResourcePriority(WebFrame*, unsigned identifier, const blink::WebURLRequest::Priority& priority)
 {
     if (m_testInterfaces->testRunner()->shouldDumpResourcePriorities()) {
         if (m_resourceIdentifierMap.find(identifier) == m_resourceIdentifierMap.end())
             m_delegate->printMessage("<unknown>");
         else
             m_delegate->printMessage(m_resourceIdentifierMap[identifier]);
         m_delegate->printMessage(" changed priority to ");
         m_delegate->printMessage(PriorityDescription(priority));
         m_delegate->printMessage("\n");
     }
@@ skipping 84 matching lines @@
 }
 
 WebNavigationPolicy WebTestProxyBase::decidePolicyForNavigation(WebFrame*, WebDataSource::ExtraData*, const WebURLRequest& request, WebNavigationType type, WebNavigationPolicy defaultPolicy, bool isRedirect)
 {
     WebNavigationPolicy result;
     if (!m_testInterfaces->testRunner()->policyDelegateEnabled())
         return defaultPolicy;
 
     m_delegate->printMessage(string("Policy delegate: attempt to load ") + URLDescription(request.url()) + " with navigation type '" + webNavigationTypeToString(type) + "'\n");
     if (m_testInterfaces->testRunner()->policyDelegateIsPermissive())
-        result = WebKit::WebNavigationPolicyCurrentTab;
+        result = blink::WebNavigationPolicyCurrentTab;
     else
-        result = WebKit::WebNavigationPolicyIgnore;
+        result = blink::WebNavigationPolicyIgnore;
 
     if (m_testInterfaces->testRunner()->policyDelegateShouldNotifyDone())
         m_testInterfaces->testRunner()->policyDelegateDone();
     return result;
 }
 
 bool WebTestProxyBase::willCheckAndDispatchMessageEvent(WebFrame*, WebFrame*, WebSecurityOrigin, WebDOMMessageEvent)
 {
     if (m_testInterfaces->testRunner()->shouldInterceptPostMessage()) {
         m_delegate->printMessage("intercepted postMessage\n");
         return true;
     }
 
     return false;
 }
 
 void WebTestProxyBase::resetInputMethod()
 {
     // If a composition text exists, then we need to let the browser process
     // to cancel the input method's ongoing composition session.
     if (m_webWidget)
         m_webWidget->confirmComposition();
 }
 
 }