// Test an unsuccessful cross-origin load using CORS.
TEST_F(AssociatedURLLoaderTest, CrossOriginWithAccessControlFailureBadStatusCode)
{
// This is cross-origin since the frame was loaded from www.test.com.
KURL url = toKURL("http://www.other.com/CrossOriginWithAccessControlFailure.html");
WebURLRequest request;
request.initialize();
request.setURL(url);
m_expectedResponse = WebURLResponse();
m_expectedResponse.initialize();
m_expectedResponse.setMIMEType("text/html");
m_expectedResponse.setHTTPStatusCode(0);
m_expectedResponse.addHTTPHeaderField("access-control-allow-origin", "*");
Platform::current()->unitTestSupport()->registerMockedURL(url, m_expectedResponse, m_frameFilePath);
WebURLLoaderOptions options;
options.crossOriginRequestPolicy = WebURLLoaderOptions::CrossOriginRequestPolicyUseAccessControl;
m_expectedLoader = createAssociatedURLLoader(options);
EXPECT_TRUE(m_expectedLoader);
m_expectedLoader->loadAsynchronously(request, this);
// Failure should not be reported synchronously.
EXPECT_FALSE(m_didFail);
// The loader needs to receive the response, before doing the CORS check.
serveRequests();
EXPECT_TRUE(m_didFail);
EXPECT_FALSE(m_didReceiveResponse);
}
void loadFrame(WebFrame* frame, const std::string& url) {
WebURLRequest urlRequest;
urlRequest.setURL(URLTestHelpers::toKURL(url));
urlRequest.setRequestorOrigin(WebSecurityOrigin::createUnique());
frame->loadRequest(urlRequest);
pumpPendingRequestsForFrameToLoad(frame);
}
void WebViewHost::willSendRequest(WebFrame* frame, unsigned, WebURLRequest& request, const WebURLResponse&)
{
if (request.url().isEmpty())
return;
request.setExtraData(webkit_support::CreateWebURLRequestExtraData(frame->document().referrerPolicy()));
}
void WebPluginContainerImpl::loadFrameRequest(
const WebURLRequest& request, const WebString& target, bool notifyNeeded, void* notifyData)
{
Frame* frame = m_element->document()->frame();
if (!frame)
return; // FIXME: send a notification in this case?
if (notifyNeeded) {
// FIXME: This is a bit of hack to allow us to observe completion of
// our frame request. It would be better to evolve FrameLoader to
// support a completion callback instead.
WebPluginLoadObserver* observer =
new WebPluginLoadObserver(this, request.url(), notifyData);
m_pluginLoadObservers.append(observer);
WebDataSourceImpl::setNextPluginLoadObserver(observer);
}
FrameLoadRequest frameRequest(request.toResourceRequest());
frameRequest.setFrameName(target);
frame->loader()->loadFrameRequest(
frameRequest,
false, // lock history
false, // lock back forward list
0, // event
0, // form state
SendReferrer);
}
// Test that the loader can allow non-whitelisted response headers for trusted CORS loads.
TEST_F(AssociatedURLLoaderTest, CrossOriginHeaderAllowResponseHeaders)
{
WebURLRequest request;
request.initialize();
KURL url = toKURL("http://www.other.com/CrossOriginHeaderAllowResponseHeaders.html");
request.setURL(url);
WebString headerNameString(WebString::fromUTF8("non-whitelisted"));
m_expectedResponse = WebURLResponse();
m_expectedResponse.initialize();
m_expectedResponse.setMIMEType("text/html");
m_expectedResponse.setHTTPStatusCode(200);
m_expectedResponse.addHTTPHeaderField("Access-Control-Allow-Origin", "*");
m_expectedResponse.addHTTPHeaderField(headerNameString, "foo");
Platform::current()->unitTestSupport()->registerMockedURL(url, m_expectedResponse, m_frameFilePath);
WebURLLoaderOptions options;
options.exposeAllResponseHeaders = true; // This turns off response whitelisting.
options.crossOriginRequestPolicy = WebURLLoaderOptions::CrossOriginRequestPolicyUseAccessControl;
m_expectedLoader = createAssociatedURLLoader(options);
EXPECT_TRUE(m_expectedLoader);
m_expectedLoader->loadAsynchronously(request, this);
serveRequests();
EXPECT_TRUE(m_didReceiveResponse);
EXPECT_TRUE(m_didReceiveData);
EXPECT_TRUE(m_didFinishLoading);
EXPECT_FALSE(m_actualResponse.httpHeaderField(headerNameString).isEmpty());
}
void BeaconLoader::willSendRequest(WebURLLoader*, WebURLRequest& passedNewRequest, const WebURLResponse& passedRedirectResponse)
{
passedNewRequest.setAllowStoredCredentials(true);
ResourceRequest& newRequest(passedNewRequest.toMutableResourceRequest());
const ResourceResponse& redirectResponse(passedRedirectResponse.toResourceResponse());
ASSERT(!newRequest.isNull());
ASSERT(!redirectResponse.isNull());
String errorDescription;
StoredCredentials withCredentials = AllowStoredCredentials;
ResourceLoaderOptions options;
if (!CrossOriginAccessControl::handleRedirect(m_beaconOrigin.get(), newRequest, redirectResponse, withCredentials, options, errorDescription)) {
if (page() && page()->mainFrame()) {
if (page()->mainFrame()->isLocalFrame()) {
LocalFrame* localFrame = toLocalFrame(page()->mainFrame());
if (localFrame->document())
localFrame->document()->addConsoleMessage(ConsoleMessage::create(JSMessageSource, ErrorMessageLevel, errorDescription));
}
}
// Cancel the load and self destruct.
dispose();
return;
}
// FIXME: http://crbug.com/427429 is needed to correctly propagate
// updates of Origin: following this successful redirect.
}
void ResourceHandleInternal::willSendRequest(
WebURLLoader*, WebURLRequest& request, const WebURLResponse& response)
{
ASSERT(m_client);
ASSERT(!request.isNull());
ASSERT(!response.isNull());
m_client->willSendRequest(m_owner, request.toMutableResourceRequest(), response.toResourceResponse());
}
void WebDevToolsAgentImpl::willSendRequest(unsigned long resourceId, WebURLRequest& request)
{
if (InspectorController* ic = inspectorController()) {
ic->willSendRequest(resourceId, request.toMutableResourceRequest(), ResourceResponse());
if (ic->hasFrontend() && request.reportLoadTiming())
request.setReportRawHeaders(true);
}
}
// Test that the same-origin restriction is the default.
TEST_F(AssociatedURLLoaderTest, SameOriginRestriction)
{
// This is cross-origin since the frame was loaded from www.test.com.
KURL url = toKURL("http://www.other.com/SameOriginRestriction.html");
WebURLRequest request;
request.initialize();
request.setURL(url);
CheckFails(request);
}
void CheckMethodFails(const char* unsafeMethod)
{
WebURLRequest request;
request.initialize();
request.setURL(toKURL("http://www.test.com/success.html"));
request.setHTTPMethod(WebString::fromUTF8(unsafeMethod));
WebURLLoaderOptions options;
options.untrustedHTTP = true;
CheckFails(request, options);
}
// WebURLLoaderClient implementation.
void willSendRequest(WebURLLoader* loader, WebURLRequest& newRequest, const WebURLResponse& redirectResponse) override
{
m_willSendRequest = true;
EXPECT_EQ(m_expectedLoader, loader);
EXPECT_EQ(m_expectedNewRequest.url(), newRequest.url());
// Check that CORS simple headers are transferred to the new request.
EXPECT_EQ(m_expectedNewRequest.httpHeaderField("accept"), newRequest.httpHeaderField("accept"));
EXPECT_EQ(m_expectedRedirectResponse.url(), redirectResponse.url());
EXPECT_EQ(m_expectedRedirectResponse.httpStatusCode(), redirectResponse.httpStatusCode());
EXPECT_EQ(m_expectedRedirectResponse.mimeType(), redirectResponse.mimeType());
}
void CheckHeaderFails(const char* headerField, const char* headerValue)
{
WebURLRequest request;
request.initialize();
request.setURL(toKURL("http://www.test.com/success.html"));
if (equalIgnoringCase(WebString::fromUTF8(headerField), "referer"))
request.setHTTPReferrer(WebString::fromUTF8(headerValue), WebReferrerPolicyDefault);
else
request.setHTTPHeaderField(WebString::fromUTF8(headerField), WebString::fromUTF8(headerValue));
WebURLLoaderOptions options;
options.untrustedHTTP = true;
CheckFails(request, options);
}
bool ResourceLoader::willFollowRedirect(
WebURLRequest& passedNewRequest,
const WebURLResponse& passedRedirectResponse) {
DCHECK(!passedNewRequest.isNull());
DCHECK(!passedRedirectResponse.isNull());
if (m_isCacheAwareLoadingActivated) {
// Fail as cache miss if cached response is a redirect.
didFail(
ResourceError::cacheMissError(m_resource->lastResourceRequest().url()));
return false;
}
ResourceRequest& newRequest(passedNewRequest.toMutableResourceRequest());
const ResourceResponse& redirectResponse(
passedRedirectResponse.toResourceResponse());
newRequest.setRedirectStatus(
ResourceRequest::RedirectStatus::FollowedRedirect);
const KURL originalURL = newRequest.url();
ResourceRequestBlockedReason blockedReason = m_fetcher->willFollowRedirect(
m_resource.get(), newRequest, redirectResponse);
if (blockedReason != ResourceRequestBlockedReason::None) {
cancelForRedirectAccessCheckError(newRequest.url(), blockedReason);
return false;
}
// ResourceFetcher::willFollowRedirect() may rewrite the URL to
// something else not for rejecting redirect but for other reasons.
// E.g. WebFrameTestClient::willSendRequest() and
// RenderFrameImpl::willSendRequest(). We should reflect the
// rewriting but currently we cannot. So, return false to make the
// redirect fail.
if (newRequest.url() != originalURL) {
cancelForRedirectAccessCheckError(newRequest.url(),
ResourceRequestBlockedReason::Other);
return false;
}
if (!m_resource->willFollowRedirect(newRequest, redirectResponse)) {
cancelForRedirectAccessCheckError(newRequest.url(),
ResourceRequestBlockedReason::Other);
return false;
}
return true;
}
void WebViewHost::loadURLExternally(WebFrame*, const WebURLRequest& request, WebNavigationPolicy policy)
{
ASSERT(policy != WebKit::WebNavigationPolicyCurrentTab);
WebViewHost* another = m_shell->createNewWindow(request.url());
if (another)
another->show(policy);
}
void WebViewHost::assignIdentifierToRequest(WebFrame*, unsigned identifier, const WebURLRequest& request)
{
if (!m_shell->shouldDumpResourceLoadCallbacks())
return;
ASSERT(!m_resourceIdentifierMap.contains(identifier));
m_resourceIdentifierMap.set(identifier, descriptionSuitableForTestResult(request.url().spec()));
}
bool WebViewHost::canHandleRequest(WebFrame*, const WebURLRequest& request)
{
GURL url = request.url();
// Just reject the scheme used in
// LayoutTests/http/tests/misc/redirect-to-external-url.html
return !url.SchemeIs("spaceballs");
}
WebNavigationPolicy WebViewHost::decidePolicyForNavigation(
WebFrame*, const WebURLRequest& request,
WebNavigationType type, const WebNode& originatingNode,
WebNavigationPolicy defaultPolicy, bool isRedirect)
{
WebNavigationPolicy result;
if (!m_policyDelegateEnabled)
return defaultPolicy;
printf("Policy delegate: attempt to load %s with navigation type '%s'",
URLDescription(request.url()).c_str(), webNavigationTypeToString(type));
if (!originatingNode.isNull()) {
fputs(" originating from ", stdout);
printNodeDescription(originatingNode, 0);
}
fputs("\n", stdout);
if (m_policyDelegateIsPermissive)
result = WebKit::WebNavigationPolicyCurrentTab;
else
result = WebKit::WebNavigationPolicyIgnore;
if (m_policyDelegateShouldNotifyDone)
layoutTestController()->policyDelegateDone();
return result;
}
void ResourceLoader::willFollowRedirect(WebURLLoader*, WebURLRequest& passedNewRequest, const WebURLResponse& passedRedirectResponse)
{
ASSERT(m_state != Terminated);
ResourceRequest& newRequest(applyOptions(passedNewRequest.toMutableResourceRequest()));
ASSERT(!newRequest.isNull());
const ResourceResponse& redirectResponse(passedRedirectResponse.toResourceResponse());
ASSERT(!redirectResponse.isNull());
newRequest.setFollowedRedirect(true);
if (!isManualRedirectFetchRequest(m_resource->resourceRequest()) && !m_fetcher->canAccessRedirect(m_resource, newRequest, redirectResponse, m_options)) {
cancel(ResourceError::cancelledDueToAccessCheckError(newRequest.url()));
return;
}
ASSERT(m_state != Terminated);
applyOptions(newRequest); // canAccessRedirect() can modify m_options so we should re-apply it.
m_fetcher->redirectReceived(m_resource, redirectResponse);
ASSERT(m_state != Terminated);
m_resource->willFollowRedirect(newRequest, redirectResponse);
if (newRequest.isNull() || m_state == Terminated)
return;
m_fetcher->willSendRequest(m_resource->identifier(), newRequest, redirectResponse, m_options.initiatorInfo);
ASSERT(m_state != Terminated);
ASSERT(!newRequest.isNull());
m_resource->updateRequest(newRequest);
m_request = newRequest;
}
void WebViewHost::willSendRequest(WebFrame*, unsigned identifier, WebURLRequest& request, const WebURLResponse& redirectResponse)
{
// Need to use GURL for host() and SchemeIs()
GURL url = request.url();
string requestURL = url.possibly_invalid_spec();
if (layoutTestController()->shouldDumpResourceLoadCallbacks()) {
GURL mainDocumentURL = request.firstPartyForCookies();
printResourceDescription(identifier);
printf(" - willSendRequest <NSURLRequest URL %s, main document URL %s,"
" http method %s> redirectResponse ",
descriptionSuitableForTestResult(requestURL).c_str(),
URLDescription(mainDocumentURL).c_str(),
request.httpMethod().utf8().data());
printResponseDescription(redirectResponse);
fputs("\n", stdout);
}
if (!redirectResponse.isNull() && m_blocksRedirects) {
fputs("Returning null for this redirect\n", stdout);
// To block the request, we set its URL to an empty one.
request.setURL(WebURL());
return;
}
if (m_requestReturnNull) {
// To block the request, we set its URL to an empty one.
request.setURL(WebURL());
return;
}
string host = url.host();
// 255.255.255.255 is used in some tests that expect to get back an error.
if (!host.empty() && (url.SchemeIs("http") || url.SchemeIs("https"))
&& host != "127.0.0.1"
&& host != "255.255.255.255"
&& host != "localhost"
&& !m_shell->allowExternalPages()) {
printf("Blocked access to external URL %s\n", requestURL.c_str());
// To block the request, we set its URL to an empty one.
request.setURL(WebURL());
return;
}
HashSet<String>::const_iterator end = m_clearHeaders.end();
for (HashSet<String>::const_iterator header = m_clearHeaders.begin(); header != end; ++header)
request.clearHTTPHeaderField(WebString(header->characters(), header->length()));
// Set the new substituted URL.
request.setURL(webkit_support::RewriteLayoutTestsURL(request.url().spec()));
}
// Test that a cross origin redirect response with CORS headers that allow the requesting origin succeeds.
TEST_F(AssociatedURLLoaderTest, RedirectCrossOriginWithAccessControlSuccess)
{
KURL url = toKURL("http://www.test.com/RedirectCrossOriginWithAccessControlSuccess.html");
char redirect[] = "http://www.other.com/RedirectCrossOriginWithAccessControlSuccess.html"; // Cross-origin
KURL redirectURL = toKURL(redirect);
WebURLRequest request;
request.initialize();
request.setURL(url);
// Add a CORS simple header.
request.setHTTPHeaderField("accept", "application/json");
// Create a redirect response that allows the redirect to pass the access control checks.
m_expectedRedirectResponse = WebURLResponse();
m_expectedRedirectResponse.initialize();
m_expectedRedirectResponse.setMIMEType("text/html");
m_expectedRedirectResponse.setHTTPStatusCode(301);
m_expectedRedirectResponse.setHTTPHeaderField("Location", redirect);
m_expectedRedirectResponse.addHTTPHeaderField("access-control-allow-origin", "*");
Platform::current()->unitTestSupport()->registerMockedURL(url, m_expectedRedirectResponse, m_frameFilePath);
m_expectedNewRequest = WebURLRequest();
m_expectedNewRequest.initialize();
m_expectedNewRequest.setURL(redirectURL);
m_expectedNewRequest.setHTTPHeaderField("accept", "application/json");
m_expectedResponse = WebURLResponse();
m_expectedResponse.initialize();
m_expectedResponse.setMIMEType("text/html");
m_expectedResponse.setHTTPStatusCode(200);
m_expectedResponse.addHTTPHeaderField("access-control-allow-origin", "*");
Platform::current()->unitTestSupport()->registerMockedURL(redirectURL, m_expectedResponse, m_frameFilePath);
WebURLLoaderOptions options;
options.crossOriginRequestPolicy = WebURLLoaderOptions::CrossOriginRequestPolicyUseAccessControl;
m_expectedLoader = createAssociatedURLLoader(options);
EXPECT_TRUE(m_expectedLoader);
m_expectedLoader->loadAsynchronously(request, this);
serveRequests();
// We should not receive a notification for the redirect.
EXPECT_FALSE(m_willSendRequest);
EXPECT_TRUE(m_didReceiveResponse);
EXPECT_TRUE(m_didReceiveData);
EXPECT_TRUE(m_didFinishLoading);
}
WebURLError WebViewHost::cannotHandleRequestError(WebFrame*, const WebURLRequest& request)
{
WebURLError error;
// A WebKit layout test expects the following values.
// unableToImplementPolicyWithError() below prints them.
error.domain = WebString::fromUTF8("WebKitErrorDomain");
error.reason = 101;
error.unreachableURL = request.url();
return error;
}
// Test a successful same-origin URL load.
TEST_F(AssociatedURLLoaderTest, SameOriginSuccess)
{
KURL url = toKURL("http://www.test.com/SameOriginSuccess.html");
WebURLRequest request;
request.initialize();
request.setURL(url);
m_expectedResponse = WebURLResponse();
m_expectedResponse.initialize();
m_expectedResponse.setMIMEType("text/html");
m_expectedResponse.setHTTPStatusCode(200);
Platform::current()->unitTestSupport()->registerMockedURL(url, m_expectedResponse, m_frameFilePath);
m_expectedLoader = createAssociatedURLLoader();
EXPECT_TRUE(m_expectedLoader);
m_expectedLoader->loadAsynchronously(request, this);
serveRequests();
EXPECT_TRUE(m_didReceiveResponse);
EXPECT_TRUE(m_didReceiveData);
EXPECT_TRUE(m_didFinishLoading);
}
//------- WebKit/plugin resource load notifications ---------------
void WebDevToolsAgentImpl::identifierForInitialRequest(
unsigned long resourceId,
WebFrame* frame,
const WebURLRequest& request)
{
if (InspectorController* ic = inspectorController()) {
WebFrameImpl* webFrameImpl = static_cast<WebFrameImpl*>(frame);
FrameLoader* frameLoader = webFrameImpl->frame()->loader();
DocumentLoader* loader = frameLoader->activeDocumentLoader();
ic->identifierForInitialRequest(resourceId, loader, request.toResourceRequest());
}
}
void WebViewHost::willSendRequest(WebFrame* frame, unsigned identifier, WebURLRequest& request, const WebURLResponse& redirectResponse)
{
if (request.url().isEmpty())
return;
// Need to use GURL for host() and SchemeIs()
GURL url = request.url();
string requestURL = url.possibly_invalid_spec();
GURL mainDocumentURL = request.firstPartyForCookies();
request.setExtraData(webkit_support::CreateWebURLRequestExtraData(frame->document().referrerPolicy()));
string host = url.host();
if (!host.empty() && (url.SchemeIs("http") || url.SchemeIs("https"))) {
if (!isLocalhost(host) && !hostIsUsedBySomeTestsToGenerateError(host)
&& ((!mainDocumentURL.SchemeIs("http") && !mainDocumentURL.SchemeIs("https")) || isLocalhost(mainDocumentURL.host()))
&& !m_shell->allowExternalPages()) {
printf("Blocked access to external URL %s\n", requestURL.c_str());
blockRequest(request);
return;
}
}
// Set the new substituted URL.
request.setURL(webkit_support::RewriteLayoutTestsURL(request.url().spec()));
}
// Test that a cross origin redirect response without CORS headers fails.
TEST_F(AssociatedURLLoaderTest, RedirectCrossOriginWithAccessControlFailure)
{
KURL url = toKURL("http://www.test.com/RedirectCrossOriginWithAccessControlFailure.html");
char redirect[] = "http://www.other.com/RedirectCrossOriginWithAccessControlFailure.html"; // Cross-origin
KURL redirectURL = toKURL(redirect);
WebURLRequest request;
request.initialize();
request.setURL(url);
m_expectedRedirectResponse = WebURLResponse();
m_expectedRedirectResponse.initialize();
m_expectedRedirectResponse.setMIMEType("text/html");
m_expectedRedirectResponse.setHTTPStatusCode(301);
m_expectedRedirectResponse.setHTTPHeaderField("Location", redirect);
Platform::current()->unitTestSupport()->registerMockedURL(url, m_expectedRedirectResponse, m_frameFilePath);
m_expectedNewRequest = WebURLRequest();
m_expectedNewRequest.initialize();
m_expectedNewRequest.setURL(redirectURL);
m_expectedResponse = WebURLResponse();
m_expectedResponse.initialize();
m_expectedResponse.setMIMEType("text/html");
m_expectedResponse.setHTTPStatusCode(200);
Platform::current()->unitTestSupport()->registerMockedURL(redirectURL, m_expectedResponse, m_frameFilePath);
WebURLLoaderOptions options;
options.crossOriginRequestPolicy = WebURLLoaderOptions::CrossOriginRequestPolicyUseAccessControl;
m_expectedLoader = createAssociatedURLLoader(options);
EXPECT_TRUE(m_expectedLoader);
m_expectedLoader->loadAsynchronously(request, this);
serveRequests();
// We should get a notification about access control check failure.
EXPECT_FALSE(m_willSendRequest);
EXPECT_FALSE(m_didReceiveResponse);
EXPECT_TRUE(m_didReceiveData);
EXPECT_TRUE(m_didFail);
}
// Test a cross-origin URL redirect without Access Control set.
TEST_F(AssociatedURLLoaderTest, RedirectCrossOriginFailure)
{
KURL url = toKURL("http://www.test.com/RedirectCrossOriginFailure.html");
char redirect[] = "http://www.other.com/RedirectCrossOriginFailure.html"; // Cross-origin
KURL redirectURL;
WebURLRequest request;
request.initialize();
request.setURL(url);
m_expectedRedirectResponse = WebURLResponse();
m_expectedRedirectResponse.initialize();
m_expectedRedirectResponse.setMIMEType("text/html");
m_expectedRedirectResponse.setHTTPStatusCode(301);
m_expectedRedirectResponse.setHTTPHeaderField("Location", redirect);
Platform::current()->unitTestSupport()->registerMockedURL(url, m_expectedRedirectResponse, m_frameFilePath);
m_expectedNewRequest = WebURLRequest();
m_expectedNewRequest.initialize();
m_expectedNewRequest.setURL(redirectURL);
m_expectedResponse = WebURLResponse();
m_expectedResponse.initialize();
m_expectedResponse.setMIMEType("text/html");
m_expectedResponse.setHTTPStatusCode(200);
Platform::current()->unitTestSupport()->registerMockedURL(redirectURL, m_expectedResponse, m_frameFilePath);
m_expectedLoader = createAssociatedURLLoader();
EXPECT_TRUE(m_expectedLoader);
m_expectedLoader->loadAsynchronously(request, this);
serveRequests();
EXPECT_FALSE(m_willSendRequest);
EXPECT_FALSE(m_didReceiveResponse);
EXPECT_FALSE(m_didReceiveData);
EXPECT_FALSE(m_didFinishLoading);
}
// Test a successful cross-origin load.
TEST_F(AssociatedURLLoaderTest, CrossOriginSuccess)
{
// This is cross-origin since the frame was loaded from www.test.com.
KURL url = toKURL("http://www.other.com/CrossOriginSuccess.html");
WebURLRequest request;
request.initialize();
request.setURL(url);
m_expectedResponse = WebURLResponse();
m_expectedResponse.initialize();
m_expectedResponse.setMIMEType("text/html");
m_expectedResponse.setHTTPStatusCode(200);
Platform::current()->unitTestSupport()->registerMockedURL(url, m_expectedResponse, m_frameFilePath);
WebURLLoaderOptions options;
options.crossOriginRequestPolicy = WebURLLoaderOptions::CrossOriginRequestPolicyAllow;
m_expectedLoader = createAssociatedURLLoader(options);
EXPECT_TRUE(m_expectedLoader);
m_expectedLoader->loadAsynchronously(request, this);
serveRequests();
EXPECT_TRUE(m_didReceiveResponse);
EXPECT_TRUE(m_didReceiveData);
EXPECT_TRUE(m_didFinishLoading);
}
bool CheckAccessControlHeaders(const char* headerName, bool exposed)
{
std::string id("http://www.other.com/CheckAccessControlExposeHeaders_");
id.append(headerName);
if (exposed)
id.append("-Exposed");
id.append(".html");
KURL url = toKURL(id);
WebURLRequest request;
request.initialize();
request.setURL(url);
WebString headerNameString(WebString::fromUTF8(headerName));
m_expectedResponse = WebURLResponse();
m_expectedResponse.initialize();
m_expectedResponse.setMIMEType("text/html");
m_expectedResponse.setHTTPStatusCode(200);
m_expectedResponse.addHTTPHeaderField("Access-Control-Allow-Origin", "*");
if (exposed)
m_expectedResponse.addHTTPHeaderField("access-control-expose-headers", headerNameString);
m_expectedResponse.addHTTPHeaderField(headerNameString, "foo");
Platform::current()->unitTestSupport()->registerMockedURL(url, m_expectedResponse, m_frameFilePath);
WebURLLoaderOptions options;
options.crossOriginRequestPolicy = WebURLLoaderOptions::CrossOriginRequestPolicyUseAccessControl;
m_expectedLoader = createAssociatedURLLoader(options);
EXPECT_TRUE(m_expectedLoader);
m_expectedLoader->loadAsynchronously(request, this);
serveRequests();
EXPECT_TRUE(m_didReceiveResponse);
EXPECT_TRUE(m_didReceiveData);
EXPECT_TRUE(m_didFinishLoading);
return !m_actualResponse.httpHeaderField(headerNameString).isEmpty();
}
TEST(WebURLRequestTest, ExtraData)
{
bool alive = false;
{
WebURLRequest urlRequest;
TestExtraData* extraData = new TestExtraData(&alive);
EXPECT_TRUE(alive);
urlRequest.initialize();
urlRequest.setExtraData(extraData);
EXPECT_EQ(extraData, urlRequest.extraData());
{
WebURLRequest otherUrlRequest = urlRequest;
EXPECT_TRUE(alive);
EXPECT_EQ(extraData, otherUrlRequest.extraData());
EXPECT_EQ(extraData, urlRequest.extraData());
}
EXPECT_TRUE(alive);
EXPECT_EQ(extraData, urlRequest.extraData());
}
EXPECT_FALSE(alive);
}
void WebDevToolsAgentImpl::willSendRequest(unsigned long resourceId, const WebURLRequest& request)
{
if (InspectorController* ic = inspectorController())
ic->willSendRequest(resourceId, request.toResourceRequest(), ResourceResponse());
}
