Verify the order of RawResourceClient callbacks in DocumentThreadableLoader

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 403 matching lines @@
 // called by RawResource::willSendRequest(). If called by
 // RawResource::didAddClient(), clearing |request| won't be propagated
 // to content::WebURLLoaderImpl. So, this loader must also get detached from
 // the resource by calling clearResource().
 void DocumentThreadableLoader::redirectReceived(Resource* resource, ResourceRequest& request, const ResourceResponse& redirectResponse)
 {
     ASSERT(m_client);
     ASSERT_UNUSED(resource, resource == this->resource());
     ASSERT(m_async);
 
+    m_checker.redirectReceived();
+
     if (!m_actualRequest.isNull()) {
         reportResponseReceived(resource->identifier(), redirectResponse);
 
         handlePreflightFailure(redirectResponse.url().getString(), "Response for preflight is invalid (redirect)");
 
         request = ResourceRequest();
 
         return;
     }
 
@@ skipping 114 matching lines @@
     request.clearHTTPUserAgent();
     // Add any CORS simple request headers which we previously saved from the original request.
     for (const auto& header : m_simpleRequestHeaders)
         request.setHTTPHeaderField(header.key, header.value);
     makeCrossOriginAccessRequest(request);
     // |this| may be dead here.
 }
 
 void DocumentThreadableLoader::redirectBlocked()
 {
+    m_checker.redirectBlocked();
+
     // Tells the client that a redirect was received but not followed (for an unknown reason).
     ThreadableLoaderClient* client = m_client;
     clear();
     client->didFailRedirectCheck();
 }
 
 void DocumentThreadableLoader::dataSent(Resource* resource, unsigned long long bytesSent, unsigned long long totalBytesToBeSent)
 {
     ASSERT(m_client);
     ASSERT_UNUSED(resource, resource == this->resource());
     ASSERT(m_async);
 
+    m_checker.dataSent();
     m_client->didSendData(bytesSent, totalBytesToBeSent);
 }
 
 void DocumentThreadableLoader::dataDownloaded(Resource* resource, int dataLength)
 {
     ASSERT(m_client);
     ASSERT_UNUSED(resource, resource == this->resource());
     ASSERT(m_actualRequest.isNull());
     ASSERT(m_async);
 
+    m_checker.dataDownloaded();
     m_client->didDownloadData(dataLength);
 }
 
 void DocumentThreadableLoader::didReceiveResourceTiming(Resource* resource, const ResourceTimingInfo& info)
 {
     ASSERT(m_client);
     ASSERT_UNUSED(resource, resource == this->resource());
     ASSERT(m_async);
 
     m_client->didReceiveResourceTiming(info);
 }
 
 void DocumentThreadableLoader::responseReceived(Resource* resource, const ResourceResponse& response, std::unique_ptr<WebDataConsumerHandle> handle)
 {
     ASSERT_UNUSED(resource, resource == this->resource());
     ASSERT(m_async);
 
+    m_checker.responseReceived();
+
     if (handle)
         m_isUsingDataConsumerHandle = true;
 
     handleResponse(resource->identifier(), response, std::move(handle));
 }
 
 void DocumentThreadableLoader::handlePreflightResponse(const ResourceResponse& response)
 {
     String accessControlErrorDescription;
 
@@ skipping 87 matching lines @@
             client->didFailAccessControlCheck(ResourceError(errorDomainBlinkInternal, 0, response.url().getString(), accessControlErrorDescription));
             return;
         }
     }
 
     m_client->didReceiveResponse(identifier, response, std::move(handle));
 }
 
 void DocumentThreadableLoader::setSerializedCachedMetadata(Resource*, const char* data, size_t size)
 {
+    m_checker.setSerializedCachedMetadata();
+
     if (!m_actualRequest.isNull())
         return;
     m_client->didReceiveCachedMetadata(data, size);
 }
 
 void DocumentThreadableLoader::dataReceived(Resource* resource, const char* data, size_t dataLength)
 {
     ASSERT_UNUSED(resource, resource == this->resource());
     ASSERT(m_async);
 
+    m_checker.dataReceived();
+
     if (m_isUsingDataConsumerHandle)
         return;
 
     // TODO(junov): Fix the ThreadableLoader ecosystem to use size_t.
     // Until then, we use safeCast to trap potential overflows.
     handleReceivedData(data, safeCast<unsigned>(dataLength));
 }
 
 void DocumentThreadableLoader::handleReceivedData(const char* data, size_t dataLength)
 {
     ASSERT(m_client);
 
     // Preflight data should be invisible to clients.
     if (!m_actualRequest.isNull())
         return;
 
     ASSERT(m_fallbackRequestForServiceWorker.isNull());
 
     m_client->didReceiveData(data, dataLength);
 }
 
 void DocumentThreadableLoader::notifyFinished(Resource* resource)
 {
     ASSERT(m_client);
     ASSERT(resource == this->resource());
     ASSERT(m_async);
 
+    m_checker.notifyFinished(resource);
+
     if (resource->errorOccurred()) {
         handleError(resource->resourceError());
     } else {
         handleSuccessfulFinish(resource->identifier(), resource->loadFinishTime());
     }
 }
 
 void DocumentThreadableLoader::handleSuccessfulFinish(unsigned long identifier, double finishTime)
 {
     ASSERT(m_fallbackRequestForServiceWorker.isNull());
@@ skipping 222 matching lines @@
 
 DEFINE_TRACE(DocumentThreadableLoader)
 {
     visitor->trace(m_resource);
     visitor->trace(m_document);
     ThreadableLoader::trace(visitor);
     RawResourceClient::trace(visitor);
 }
 
 } // namespace blink