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 847 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 63 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 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 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 33 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)
 {
     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();
 }
 
 }