Enable the CORS preflight for sendBeacon()

third_party/WebKit/Source/core/loader/DocumentThreadableLoader.cpp

 /*
  * Copyright (C) 2011, 2012 Google Inc. All rights reserved.
  * Copyright (C) 2013, Intel Corporation
  *
  * 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.
@@ skipping 31 matching lines @@
 #include "core/inspector/InspectorInstrumentation.h"
 #include "core/inspector/InspectorTraceEvents.h"
 #include "core/loader/CrossOriginPreflightResultCache.h"
 #include "core/loader/DocumentThreadableLoaderClient.h"
 #include "core/loader/FrameLoader.h"
 #include "core/loader/FrameLoaderClient.h"
 #include "core/loader/ThreadableLoaderClient.h"
 #include "core/page/ChromeClient.h"
 #include "core/page/Page.h"
 #include "platform/SharedBuffer.h"
+#include "platform/WebFrameScheduler.h"
+#include "platform/network/NetworkLog.h"
 #include "platform/network/ResourceRequest.h"
 #include "platform/weborigin/SchemeRegistry.h"
 #include "platform/weborigin/SecurityOrigin.h"
 #include "platform/weborigin/SecurityPolicy.h"
 #include "public/platform/Platform.h"
 #include "public/platform/WebURLRequest.h"
 #include "wtf/Assertions.h"
 #include "wtf/PtrUtil.h"
 #include "wtf/WeakPtr.h"
 #include <memory>
@@ skipping 627 matching lines @@
   m_checker.responseReceived();
 
   if (handle)
     m_isUsingDataConsumerHandle = true;
 
   handleResponse(resource->identifier(), response, std::move(handle));
 }
 
 void DocumentThreadableLoader::handlePreflightResponse(
     const ResourceResponse& response) {
+  NETWORK_DVLOG(1) << this << " handlePreflightResponse()";
+
   String accessControlErrorDescription;
 
   if (!passesAccessControlCheck(
           response, effectiveAllowCredentials(), getSecurityOrigin(),
           accessControlErrorDescription, m_requestContext)) {
     handlePreflightFailure(
         response.url().getString(),
         "Response to preflight request doesn't pass access control check: " +
             accessControlErrorDescription);
+    NETWORK_DVLOG(1) << this << " 2()";
     return;
   }
 
   if (!passesPreflightStatusCheck(response, accessControlErrorDescription)) {
     handlePreflightFailure(response.url().getString(),
                            accessControlErrorDescription);
+    NETWORK_DVLOG(1) << this << " 1()";
     return;
   }
 
   if (m_actualRequest.isExternalRequest() &&
       !passesExternalPreflightCheck(response, accessControlErrorDescription)) {
     handlePreflightFailure(response.url().getString(),
                            accessControlErrorDescription);
+    NETWORK_DVLOG(1) << this << " 3()";
     return;
   }
 
   std::unique_ptr<CrossOriginPreflightResultCacheItem> preflightResult =
       WTF::wrapUnique(
           new CrossOriginPreflightResultCacheItem(effectiveAllowCredentials()));
   if (!preflightResult->parse(response, accessControlErrorDescription) ||
       !preflightResult->allowsCrossOriginMethod(
           m_actualRequest.httpMethod(), accessControlErrorDescription) ||
       !preflightResult->allowsCrossOriginHeaders(
           m_actualRequest.httpHeaderFields(), accessControlErrorDescription)) {
     handlePreflightFailure(response.url().getString(),
                            accessControlErrorDescription);
+    NETWORK_DVLOG(1) << this << " 4() "
+                     << accessControlErrorDescription.utf8().data();
     return;
   }
 
   CrossOriginPreflightResultCache::shared().appendEntry(
       getSecurityOrigin()->toString(), m_actualRequest.url(),
       std::move(preflightResult));
 }
 
 void DocumentThreadableLoader::reportResponseReceived(
     unsigned long identifier,
@@ skipping 242 matching lines @@
     // synchronously, and in such cases ThreadableLoaderClient is already
     // notified and |client| is null.
     if (!client)
       return;
     client->didFail(ResourceError(errorDomainBlinkInternal, 0,
                                   request.url().getString(),
                                   "Failed to start loading."));
     return;
   }
 
-  if (resource()->isLoading()) {
-    unsigned long identifier = resource()->identifier();
-    InspectorInstrumentation::documentThreadableLoaderStartedLoadingForClient(
-        m_document, identifier, m_client);
-  } else {
+  if (!resource()->isLoading()) {
     InspectorInstrumentation::
         documentThreadableLoaderFailedToStartLoadingForClient(m_document,
                                                               m_client);
+    return;
+  }
+
+  unsigned long identifier = resource()->identifier();
+  InspectorInstrumentation::documentThreadableLoaderStartedLoadingForClient(
+      m_document, identifier, m_client);
+
+  if (m_options.schedulerWaitingPolicy == PreventSchedulerFromWaiting) {
+    LocalFrame* frame = document().frame();
+    if (frame && frame->frameScheduler())
+      frame->frameScheduler()->didStopLoading(identifier);
   }
 }
 
 void DocumentThreadableLoader::loadRequestSync(
     const ResourceRequest& request,
     ResourceLoaderOptions resourceLoaderOptions) {
   FetchRequest fetchRequest(request, m_options.initiator,
                             resourceLoaderOptions);
   if (m_options.crossOriginRequestPolicy == AllowCrossOriginRequests)
     fetchRequest.setOriginRestriction(FetchRequest::NoOriginRestriction);
@@ skipping 102 matching lines @@
 }
 
 DEFINE_TRACE(DocumentThreadableLoader) {
   visitor->trace(m_resource);
   visitor->trace(m_document);
   ThreadableLoader::trace(visitor);
   RawResourceClient::trace(visitor);
 }
 
 }  // namespace blink