Conversion of content_shell target to use WebLocalFrame.

content/shell/renderer/test_runner/WebTestProxy.cpp

 // Copyright 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 "content/shell/renderer/test_runner/WebTestProxy.h"
 
 #include <cctype>
 
 #include "content/shell/renderer/test_runner/event_sender.h"
 #include "content/shell/renderer/test_runner/MockColorChooser.h"
@@ skipping 17 matching lines @@
 #include "third_party/WebKit/public/platform/WebURLResponse.h"
 #include "third_party/WebKit/public/web/WebAXEnums.h"
 #include "third_party/WebKit/public/web/WebAXObject.h"
 #include "third_party/WebKit/public/web/WebCachedURLRequest.h"
 #include "third_party/WebKit/public/web/WebConsoleMessage.h"
 #include "third_party/WebKit/public/web/WebDataSource.h"
 #include "third_party/WebKit/public/web/WebDocument.h"
 #include "third_party/WebKit/public/web/WebElement.h"
 #include "third_party/WebKit/public/web/WebFrame.h"
 #include "third_party/WebKit/public/web/WebHistoryItem.h"
+#include "third_party/WebKit/public/web/WebLocalFrame.h"
 #include "third_party/WebKit/public/web/WebMIDIClientMock.h"
 #include "third_party/WebKit/public/web/WebNode.h"
 #include "third_party/WebKit/public/web/WebPluginParams.h"
 #include "third_party/WebKit/public/web/WebPrintParams.h"
 #include "third_party/WebKit/public/web/WebRange.h"
 #include "third_party/WebKit/public/web/WebUserGestureIndicator.h"
 #include "third_party/WebKit/public/web/WebView.h"
 
 using namespace blink;
 using namespace std;
@@ skipping 816 matching lines @@
             if (element.hasAttribute("id")) {
                 message += " - id:";
                 message += element.getAttribute("id").utf8().data();
             }
         }
 
         m_delegate->printMessage(message + "\n");
     }
 }
 
-void WebTestProxyBase::startDragging(WebFrame*, const WebDragData& data, WebDragOperationsMask mask, const WebImage&, const WebPoint&)
-{
+void WebTestProxyBase::startDragging(WebLocalFrame*,
+                                     const WebDragData& data,
+                                     WebDragOperationsMask mask,
+                                     const WebImage&,
+                                     const WebPoint&) {
     // When running a test, we need to fake a drag drop operation otherwise
     // Windows waits for real mouse events to know when the drag is over.
     m_testInterfaces->eventSender()->DoDragDrop(data, mask);
 }
 
 // The output from these methods in layout test mode should match that
 // expected by the layout tests. See EditingDelegate.m in DumpRenderTree.
 
 void WebTestProxyBase::didChangeSelection(bool isEmptySelection)
 {
     if (m_testInterfaces->testRunner()->shouldDumpEditingCallbacks())
         m_delegate->printMessage("EDITING DELEGATE: webViewDidChangeSelection:WebViewDidChangeSelectionNotification\n");
 }
 
 void WebTestProxyBase::didChangeContents()
 {
     if (m_testInterfaces->testRunner()->shouldDumpEditingCallbacks())
         m_delegate->printMessage("EDITING DELEGATE: webViewDidChange:WebViewDidChangeNotification\n");
 }
 
-bool WebTestProxyBase::createView(WebFrame*, const WebURLRequest& request, const WebWindowFeatures&, const WebString&, WebNavigationPolicy, bool)
-{
+bool WebTestProxyBase::createView(WebLocalFrame*,
+                                  const WebURLRequest& request,
+                                  const WebWindowFeatures&,
+                                  const WebString&,
+                                  WebNavigationPolicy,
+                                  bool) {
     if (!m_testInterfaces->testRunner()->canOpenWindows())
         return false;
     if (m_testInterfaces->testRunner()->shouldDumpCreateView())
         m_delegate->printMessage(string("createView(") + URLDescription(request.url()) + ")\n");
     return true;
 }
 
-WebPlugin* WebTestProxyBase::createPlugin(WebFrame* frame, const WebPluginParams& params)
-{
+WebPlugin* WebTestProxyBase::createPlugin(WebLocalFrame* frame,
+                                          const WebPluginParams& params) {
     if (TestPlugin::isSupportedMimeType(params.mimeType))
         return TestPlugin::create(frame, params, m_delegate);
     return 0;
 }
 
 void WebTestProxyBase::setStatusText(const WebString& text)
 {
     if (!m_testInterfaces->testRunner()->shouldDumpStatusCallbacks())
         return;
     m_delegate->printMessage(string("UI DELEGATE STATUS CALLBACK: setStatusText:") + text.utf8().data() + "\n");
 }
 
 void WebTestProxyBase::didStopLoading()
 {
     if (m_testInterfaces->testRunner()->shouldDumpProgressFinishedCallback())
         m_delegate->printMessage("postProgressFinishedNotification\n");
 }
 
-void WebTestProxyBase::showContextMenu(WebFrame*, const WebContextMenuData& contextMenuData)
-{
+void WebTestProxyBase::showContextMenu(
+    WebLocalFrame*,
+    const WebContextMenuData& contextMenuData) {
     m_testInterfaces->eventSender()->SetContextMenuData(contextMenuData);
 }
 
 WebUserMediaClient* WebTestProxyBase::userMediaClient()
 {
     if (!m_userMediaClient.get())
         m_userMediaClient.reset(new WebUserMediaClientMock(m_delegate));
     return m_userMediaClient.get();
 }
 
 // Simulate a print by going into print mode and then exit straight away.
-void WebTestProxyBase::printPage(WebFrame* frame)
-{
+void WebTestProxyBase::printPage(WebLocalFrame* frame) {
     WebSize pageSizeInPixels = webWidget()->size();
     if (pageSizeInPixels.isEmpty())
         return;
     WebPrintParams printParams(pageSizeInPixels);
     frame->printBegin(printParams);
     frame->printEnd();
 }
 
 WebNotificationPresenter* WebTestProxyBase::notificationPresenter()
 {
@@ skipping 62 matching lines @@
 void WebTestProxyBase::didCloseChooser()
 {
     m_chooserCount--;
 }
 
 bool WebTestProxyBase::isChooserShown()
 {
     return 0 < m_chooserCount;
 }
 
-void WebTestProxyBase::didStartProvisionalLoad(WebFrame* frame)
-{
+void WebTestProxyBase::didStartProvisionalLoad(WebLocalFrame* frame) {
     if (!m_testInterfaces->testRunner()->topLoadingFrame())
         m_testInterfaces->testRunner()->setTopLoadingFrame(frame, false);
 
     if (m_testInterfaces->testRunner()->shouldDumpFrameLoadCallbacks()) {
         printFrameDescription(m_delegate, frame);
         m_delegate->printMessage(" - didStartProvisionalLoadForFrame\n");
     }
 
     if (m_testInterfaces->testRunner()->shouldDumpUserGestureInFrameLoadCallbacks())
         printFrameUserGestureStatus(m_delegate, frame, " - in didStartProvisionalLoadForFrame\n");
 }
 
-void WebTestProxyBase::didReceiveServerRedirectForProvisionalLoad(WebFrame* frame)
-{
+void WebTestProxyBase::didReceiveServerRedirectForProvisionalLoad(
+    WebLocalFrame* frame) {
     if (m_testInterfaces->testRunner()->shouldDumpFrameLoadCallbacks()) {
         printFrameDescription(m_delegate, frame);
         m_delegate->printMessage(" - didReceiveServerRedirectForProvisionalLoadForFrame\n");
     }
 }
 
-bool WebTestProxyBase::didFailProvisionalLoad(WebFrame* frame, const WebURLError&)
-{
+bool WebTestProxyBase::didFailProvisionalLoad(WebLocalFrame* frame,
+                                              const WebURLError&) {
     if (m_testInterfaces->testRunner()->shouldDumpFrameLoadCallbacks()) {
         printFrameDescription(m_delegate, frame);
         m_delegate->printMessage(" - didFailProvisionalLoadWithError\n");
     }
     locationChangeDone(frame);
     return !frame->provisionalDataSource();
 }
 
-void WebTestProxyBase::didCommitProvisionalLoad(WebFrame* frame, bool)
-{
+void WebTestProxyBase::didCommitProvisionalLoad(WebLocalFrame* frame, bool) {
     if (m_testInterfaces->testRunner()->shouldDumpFrameLoadCallbacks()) {
         printFrameDescription(m_delegate, frame);
         m_delegate->printMessage(" - didCommitLoadForFrame\n");
     }
 }
 
-void WebTestProxyBase::didReceiveTitle(WebFrame* frame, const WebString& title, WebTextDirection direction)
-{
+void WebTestProxyBase::didReceiveTitle(WebLocalFrame* frame,
+                                       const WebString& title,
+                                       WebTextDirection direction) {
     WebCString title8 = title.utf8();
 
     if (m_testInterfaces->testRunner()->shouldDumpFrameLoadCallbacks()) {
         printFrameDescription(m_delegate, frame);
         m_delegate->printMessage(string(" - didReceiveTitle: ") + title8.data() + "\n");
     }
 
     if (m_testInterfaces->testRunner()->shouldDumpTitleChanges())
         m_delegate->printMessage(string("TITLE CHANGED: '") + title8.data() + "'\n");
 }
 
-void WebTestProxyBase::didChangeIcon(WebFrame* frame, WebIconURL::Type)
-{
+void WebTestProxyBase::didChangeIcon(WebLocalFrame* frame, WebIconURL::Type) {
     if (m_testInterfaces->testRunner()->shouldDumpIconChanges()) {
         printFrameDescription(m_delegate, frame);
         m_delegate->printMessage(string(" - didChangeIcons\n"));
     }
 }
 
-void WebTestProxyBase::didFinishDocumentLoad(WebFrame* frame)
-{
+void WebTestProxyBase::didFinishDocumentLoad(WebLocalFrame* frame) {
     if (m_testInterfaces->testRunner()->shouldDumpFrameLoadCallbacks()) {
         printFrameDescription(m_delegate, frame);
         m_delegate->printMessage(" - didFinishDocumentLoadForFrame\n");
     } else {
         unsigned pendingUnloadEvents = frame->unloadListenerCount();
         if (pendingUnloadEvents) {
             printFrameDescription(m_delegate, frame);
             char buffer[100];
             snprintf(buffer, sizeof(buffer), " - has %u onunload handler(s)\n", pendingUnloadEvents);
             m_delegate->printMessage(buffer);
         }
     }
 }
 
-void WebTestProxyBase::didHandleOnloadEvents(WebFrame* frame)
-{
+void WebTestProxyBase::didHandleOnloadEvents(WebLocalFrame* frame) {
     if (m_testInterfaces->testRunner()->shouldDumpFrameLoadCallbacks()) {
         printFrameDescription(m_delegate, frame);
         m_delegate->printMessage(" - didHandleOnloadEventsForFrame\n");
     }
 }
 
-void WebTestProxyBase::didFailLoad(WebFrame* frame, const WebURLError&)
-{
+void WebTestProxyBase::didFailLoad(WebLocalFrame* frame, const WebURLError&) {
     if (m_testInterfaces->testRunner()->shouldDumpFrameLoadCallbacks()) {
         printFrameDescription(m_delegate, frame);
         m_delegate->printMessage(" - didFailLoadWithError\n");
     }
     locationChangeDone(frame);
 }
 
-void WebTestProxyBase::didFinishLoad(WebFrame* frame)
-{
+void WebTestProxyBase::didFinishLoad(WebLocalFrame* frame) {
     if (m_testInterfaces->testRunner()->shouldDumpFrameLoadCallbacks()) {
         printFrameDescription(m_delegate, frame);
         m_delegate->printMessage(" - didFinishLoadForFrame\n");
     }
     locationChangeDone(frame);
 }
 
-void WebTestProxyBase::didDetectXSS(WebFrame*, const WebURL&, bool)
-{
+void WebTestProxyBase::didDetectXSS(WebLocalFrame*, const WebURL&, bool) {
     if (m_testInterfaces->testRunner()->shouldDumpFrameLoadCallbacks())
         m_delegate->printMessage("didDetectXSS\n");
 }
 
-void WebTestProxyBase::didDispatchPingLoader(WebFrame*, const WebURL& url)
-{
+void WebTestProxyBase::didDispatchPingLoader(WebLocalFrame*,
+                                             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 blink::WebCachedURLRequest& request)
-{
+void WebTestProxyBase::willRequestResource(
+    WebLocalFrame* 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::willSendRequest(WebFrame*, unsigned identifier, blink::WebURLRequest& request, const blink::WebURLResponse& redirectResponse)
-{
+void WebTestProxyBase::willSendRequest(
+    WebLocalFrame*,
+    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 35 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 blink::WebURLResponse& response)
-{
+void WebTestProxyBase::didReceiveResponse(
+    WebLocalFrame*,
+    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 blink::WebURLRequest::Priority& priority)
-{
+void WebTestProxyBase::didChangeResourcePriority(
+    WebLocalFrame*,
+    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");
     }
 }
 
-void WebTestProxyBase::didFinishResourceLoad(WebFrame*, unsigned identifier)
-{
+void WebTestProxyBase::didFinishResourceLoad(WebLocalFrame*,
+                                             unsigned identifier) {
     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(" - didFinishLoading\n");
     }
     m_resourceIdentifierMap.erase(identifier);
 }
 
@@ skipping 32 matching lines @@
         size_t fileProtocol = newMessage.find("file://");
         if (fileProtocol != string::npos) {
             newMessage = newMessage.substr(0, fileProtocol)
                 + urlSuitableForTestResult(newMessage.substr(fileProtocol));
         }
         m_delegate->printMessage(newMessage);
     }
     m_delegate->printMessage(string("\n"));
 }
 
-void WebTestProxyBase::runModalAlertDialog(WebFrame*, const WebString& message)
-{
+void WebTestProxyBase::runModalAlertDialog(WebLocalFrame*,
+                                           const WebString& message) {
     m_delegate->printMessage(string("ALERT: ") + message.utf8().data() + "\n");
 }
 
-bool WebTestProxyBase::runModalConfirmDialog(WebFrame*, const WebString& message)
-{
+bool WebTestProxyBase::runModalConfirmDialog(WebLocalFrame*,
+                                             const WebString& message) {
     m_delegate->printMessage(string("CONFIRM: ") + message.utf8().data() + "\n");
     return true;
 }
 
-bool WebTestProxyBase::runModalPromptDialog(WebFrame* frame, const WebString& message, const WebString& defaultValue, WebString*)
-{
+bool WebTestProxyBase::runModalPromptDialog(WebLocalFrame* frame,
+                                            const WebString& message,
+                                            const WebString& defaultValue,
+                                            WebString*) {
     m_delegate->printMessage(string("PROMPT: ") + message.utf8().data() + ", default text: " + defaultValue.utf8().data() + "\n");
     return true;
 }
 
-bool WebTestProxyBase::runModalBeforeUnloadDialog(WebFrame*, const WebString& message)
-{
+bool WebTestProxyBase::runModalBeforeUnloadDialog(WebLocalFrame*,
+                                                  const WebString& message) {
     m_delegate->printMessage(string("CONFIRM NAVIGATION: ") + message.utf8().data() + "\n");
     return !m_testInterfaces->testRunner()->shouldStayOnPageAfterHandlingBeforeUnload();
 }
 
-void WebTestProxyBase::locationChangeDone(WebFrame* frame)
-{
+void WebTestProxyBase::locationChangeDone(WebLocalFrame* frame) {
     if (frame != m_testInterfaces->testRunner()->topLoadingFrame())
         return;
     m_testInterfaces->testRunner()->setTopLoadingFrame(frame, true);
 }
 
-WebNavigationPolicy WebTestProxyBase::decidePolicyForNavigation(WebFrame*, WebDataSource::ExtraData*, const WebURLRequest& request, WebNavigationType type, WebNavigationPolicy defaultPolicy, bool isRedirect)
-{
+WebNavigationPolicy WebTestProxyBase::decidePolicyForNavigation(
+    WebLocalFrame*,
+    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 = blink::WebNavigationPolicyCurrentTab;
     else
         result = blink::WebNavigationPolicyIgnore;
 
     if (m_testInterfaces->testRunner()->policyDelegateShouldNotifyDone())
         m_testInterfaces->testRunner()->policyDelegateDone();
     return result;
 }
 
-bool WebTestProxyBase::willCheckAndDispatchMessageEvent(WebFrame*, WebFrame*, WebSecurityOrigin, WebDOMMessageEvent)
-{
+bool WebTestProxyBase::willCheckAndDispatchMessageEvent(WebLocalFrame*,
+                                                        WebFrame*,
+                                                        WebSecurityOrigin,
+                                                        WebDOMMessageEvent) {
     if (m_testInterfaces->testRunner()->shouldInterceptPostMessage()) {
         m_delegate->printMessage("intercepted postMessage\n");
         return true;
     }
 
     return false;
 }
 
 void WebTestProxyBase::postSpellCheckEvent(const WebString& eventName)
 {
     if (m_testInterfaces->testRunner()->shouldDumpSpellCheckCallbacks()) {
         m_delegate->printMessage(string("SpellCheckEvent: ") + eventName.utf8().data() + "\n");
     }
 }
 
 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();
 }
 
 }