Send encoded_body_length to renderer when response completed (2/3)

third_party/WebKit/Source/core/fetch/ResourceLoader.cpp

 /*
  * Copyright (C) 2006, 2007, 2010, 2011 Apple Inc. All rights reserved.
  *           (C) 2007 Graham Dennis (graham.dennis@gmail.com)
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  *
  * 1.  Redistributions of source code must retain the above copyright
  *     notice, this list of conditions and the following disclaimer.
@@ skipping 201 matching lines @@
 }
 
 void ResourceLoader::didReceiveResponse(WebURLLoader* loader,
                                         const WebURLResponse& response) {
   didReceiveResponse(loader, response, nullptr);
 }
 
 void ResourceLoader::didReceiveData(WebURLLoader*,
                                     const char* data,
                                     int length,
-                                    int encodedDataLength,
-                                    int encodedBodyLength) {
+                                    int encodedDataLength) {
   CHECK_GE(length, 0);
   m_fetcher->didReceiveData(m_resource.get(), data, length, encodedDataLength);
-  m_resource->addToEncodedBodyLength(encodedBodyLength);
   m_resource->addToDecodedBodyLength(length);
   m_resource->appendData(data, length);
 }
 
 void ResourceLoader::didFinishLoadingFirstPartInMultipart() {
   m_fetcher->didFinishLoading(m_resource.get(), 0,
                               ResourceFetcher::DidFinishFirstPartInMultipart);
 }
 
 void ResourceLoader::didFinishLoading(WebURLLoader*,
                                       double finishTime,
-                                      int64_t encodedDataLength) {
+                                      int64_t encodedDataLength,
+                                      int64_t encodedBodyLength) {
   m_resource->setEncodedDataLength(encodedDataLength);
+  m_resource->addToEncodedBodyLength(encodedBodyLength);
   m_loader.reset();
   m_fetcher->didFinishLoading(m_resource.get(), finishTime,
                               ResourceFetcher::DidFinishLoading);
 }
 
 void ResourceLoader::didFail(WebURLLoader*,
                              const WebURLError& error,
-                             int64_t encodedDataLength) {
+                             int64_t encodedDataLength,
+                             int64_t encodedBodyLength) {
   m_resource->setEncodedDataLength(encodedDataLength);
+  m_resource->addToEncodedBodyLength(encodedBodyLength);
   didFail(error);
 }
 
 void ResourceLoader::didFail(const ResourceError& error) {
   if (m_isCacheAwareLoadingActivated && error.isCacheMiss() &&
       m_fetcher->context().shouldLoadNewResource(m_resource->getType())) {
     m_resource->willReloadAfterDiskCacheMiss();
     m_isCacheAwareLoadingActivated = false;
     restart(m_resource->resourceRequest(),
             m_fetcher->context().loadingTaskRunner(),
             m_fetcher->context().defersLoading());
     return;
   }
 
   m_loader.reset();
   m_fetcher->didFailLoading(m_resource.get(), error);
 }
 
 void ResourceLoader::requestSynchronously(const ResourceRequest& request) {
   // downloadToFile is not supported for synchronous requests.
   DCHECK(!request.downloadToFile());
   DCHECK(m_loader);
   DCHECK_EQ(request.priority(), ResourceLoadPriorityHighest);
 
   WrappedResourceRequest requestIn(request);
   WebURLResponse responseOut;
   WebURLError errorOut;
   WebData dataOut;
   int64_t encodedDataLength = WebURLLoaderClient::kUnknownEncodedDataLength;
+  int64_t encodedBodyLength = 0;
   m_loader->loadSynchronously(requestIn, responseOut, errorOut, dataOut,
-                              encodedDataLength);
+                              encodedDataLength, encodedBodyLength);
 
   // A message dispatched while synchronously fetching the resource
   // can bring about the cancellation of this load.
   if (!m_loader)
     return;
   if (errorOut.reason) {
-    didFail(0, errorOut, encodedDataLength);
+    didFail(0, errorOut, encodedDataLength, encodedBodyLength);
     return;
   }
   didReceiveResponse(0, responseOut);
   if (!m_loader)
     return;
   DCHECK_GE(responseOut.toResourceResponse().encodedBodyLength(), 0);
 
   // Follow the async case convention of not calling didReceiveData or
   // appending data to m_resource if the response body is empty. Copying the
   // empty buffer is a noop in most cases, but is destructive in the case of
   // a 304, where it will overwrite the cached data we should be reusing.
   if (dataOut.size()) {
     m_fetcher->didReceiveData(m_resource.get(), dataOut.data(), dataOut.size(),
                               encodedDataLength);
     m_resource->setResourceBuffer(dataOut);
   }
-  didFinishLoading(0, monotonicallyIncreasingTime(), encodedDataLength);
+  didFinishLoading(0, monotonicallyIncreasingTime(), encodedDataLength,
+                   encodedBodyLength);
 }
 
 void ResourceLoader::activateCacheAwareLoadingIfNeeded(
     const ResourceRequest& request) {
   DCHECK(!m_isCacheAwareLoadingActivated);
 
   if (m_resource->options().cacheAwareLoadingEnabled !=
       IsCacheAwareLoadingEnabled)
     return;
 
   // Synchronous requests are not supported.
   if (m_resource->options().synchronousPolicy == RequestSynchronously)
     return;
 
   // Don't activate on Resource revalidation.
   if (m_resource->isCacheValidator())
     return;
 
   // Don't activate if cache policy is explicitly set.
   if (request.getCachePolicy() != WebCachePolicy::UseProtocolCachePolicy)
     return;
 
   m_isCacheAwareLoadingActivated = true;
 }
 
 }  // namespace blink