[XHR] Ignore didReceiveData when having a DataConsumerHandle.

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 70 matching lines @@
 
 DocumentThreadableLoader::DocumentThreadableLoader(Document& document, ThreadableLoaderClient* client, BlockingBehavior blockingBehavior, const ResourceRequest& request, const ThreadableLoaderOptions& options, const ResourceLoaderOptions& resourceLoaderOptions)
     : m_client(client)
     , m_document(document)
     , m_options(options)
     , m_resourceLoaderOptions(resourceLoaderOptions)
     , m_forceDoNotAllowStoredCredentials(false)
     , m_securityOrigin(m_resourceLoaderOptions.securityOrigin)
     , m_sameOriginRequest(securityOrigin()->canRequest(request.url()))
     , m_crossOriginNonSimpleRequest(false)
+    , m_isUsingDataConsumerHandle(false)
     , m_async(blockingBehavior == LoadAsynchronously)
     , m_requestContext(request.requestContext())
     , m_timeoutTimer(this, &DocumentThreadableLoader::didTimeout)
     , m_requestStartedSeconds(0.0)
     , m_corsRedirectLimit(kMaxCORSRedirects)
 {
     ASSERT(client);
     // Setting an outgoing referer is only supported in the async code path.
     ASSERT(m_async || request.httpReferrer().isEmpty());
 
@@ skipping 265 matching lines @@
     ASSERT(m_async);
 
     m_client->didDownloadData(dataLength);
 }
 
 void DocumentThreadableLoader::responseReceived(Resource* resource, const ResourceResponse& response, PassOwnPtr<WebDataConsumerHandle> handle)
 {
     ASSERT_UNUSED(resource, resource == this->resource());
     ASSERT(m_async);
 
+    if (handle)
+        m_isUsingDataConsumerHandle = true;
+
     handleResponse(resource->identifier(), response, handle);
 }
 
 void DocumentThreadableLoader::handlePreflightResponse(const ResourceResponse& response)
 {
     String accessControlErrorDescription;
 
     if (!passesAccessControlCheck(response, effectiveAllowCredentials(), securityOrigin(), accessControlErrorDescription)) {
         handlePreflightFailure(response.url().string(), accessControlErrorDescription);
         return;
@@ skipping 83 matching lines @@
 }
 
 void DocumentThreadableLoader::handleReceivedData(const char* data, unsigned dataLength)
 {
     ASSERT(m_client);
 
     // Preflight data should be invisible to clients.
     if (m_actualRequest)
         return;
 
+    if (m_isUsingDataConsumerHandle)
+        return;

[tyoshino (SeeGerritForStatus), 2015/05/26 08:12:01]

write the reason why this should be here, not in dataReceived, in the CL
description.

[yhirano, 2015/05/26 08:41:03]

Actually, I don't mind: either are OK. Do you think dataReceived is more
preferable?

[tyoshino (SeeGerritForStatus), 2015/05/28 05:29:55]

We have handleReceivedData() factored out as a function since it's common for
both sync and async XHR. We have handleResponse() for the same reason. It's good
to have the new code in responseReceived() since it's needed only for async
case. So, basically this code should also live in dataReceived() handler which
implements RawResourceClient.

[yhirano, 2015/05/28 05:44:37]

Done.

+
     ASSERT(!m_fallbackRequestForServiceWorker);
 
     m_client->didReceiveData(data, dataLength);
 }
 
 void DocumentThreadableLoader::notifyFinished(Resource* resource)
 {
     ASSERT(m_client);
     ASSERT(resource == this->resource());
     ASSERT(m_async);
@@ skipping 159 matching lines @@
         return DoNotAllowStoredCredentials;
     return m_resourceLoaderOptions.allowCredentials;
 }
 
 SecurityOrigin* DocumentThreadableLoader::securityOrigin() const
 {
     return m_securityOrigin ? m_securityOrigin.get() : m_document.securityOrigin();
 }
 
 } // namespace blink