Send the decoded size when response completed and stop summing in ResourceLoader::DidReceiveData()

third_party/WebKit/Source/platform/loader/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 382 matching lines @@
 void ResourceLoader::DidDownloadData(int length, int encoded_data_length) {
   Context().DispatchDidDownloadData(resource_->Identifier(), length,
                                     encoded_data_length);
   resource_->DidDownloadData(length);
 }
 
 void ResourceLoader::DidReceiveData(const char* data, int length) {
   CHECK_GE(length, 0);
 
   Context().DispatchDidReceiveData(resource_->Identifier(), data, length);
-  resource_->AddToDecodedBodyLength(length);
   resource_->AppendData(data, length);
 }
 
 void ResourceLoader::DidReceiveTransferSizeUpdate(int transfer_size_diff) {
   DCHECK_GT(transfer_size_diff, 0);
   Context().DispatchDidReceiveEncodedData(resource_->Identifier(),
                                           transfer_size_diff);
 }
 
 void ResourceLoader::DidFinishLoadingFirstPartInMultipart() {
   network_instrumentation::endResourceLoad(
       resource_->Identifier(),
       network_instrumentation::RequestOutcome::Success);
 
   fetcher_->HandleLoaderFinish(resource_.Get(), 0,
                                ResourceFetcher::kDidFinishFirstPartInMultipart);
 }
 
 void ResourceLoader::DidFinishLoading(double finish_time,
                                       int64_t encoded_data_length,
-                                      int64_t encoded_body_length) {
+                                      int64_t encoded_body_length,
+                                      int64_t decoded_body_length) {
   resource_->SetEncodedDataLength(encoded_data_length);
-  resource_->AddToEncodedBodyLength(encoded_body_length);
+  resource_->SetEncodedBodyLength(encoded_body_length);
+  resource_->SetDecodedBodyLength(decoded_body_length);
 
   loader_.reset();
 
   network_instrumentation::endResourceLoad(
       resource_->Identifier(),
       network_instrumentation::RequestOutcome::Success);
 
   fetcher_->HandleLoaderFinish(resource_.Get(), finish_time,
                                ResourceFetcher::kDidFinishLoading);
 }
 
 void ResourceLoader::DidFail(const WebURLError& error,
                              int64_t encoded_data_length,
-                             int64_t encoded_body_length) {
+                             int64_t encoded_body_length,
+                             int64_t decoded_body_length) {
   resource_->SetEncodedDataLength(encoded_data_length);
-  resource_->AddToEncodedBodyLength(encoded_body_length);
+  resource_->SetEncodedBodyLength(encoded_body_length);
+  resource_->SetDecodedBodyLength(decoded_body_length);
   HandleError(error);
 }
 
 void ResourceLoader::HandleError(const ResourceError& error) {
   if (is_cache_aware_loading_activated_ && error.IsCacheMiss() &&
       Context().ShouldLoadNewResource(resource_->GetType())) {
     resource_->WillReloadAfterDiskCacheMiss();
     is_cache_aware_loading_activated_ = false;
     Restart(resource_->GetResourceRequest());
     return;
@@ skipping 19 matching lines @@
   WebData data_out;
   int64_t encoded_data_length = WebURLLoaderClient::kUnknownEncodedDataLength;
   int64_t encoded_body_length = 0;
   loader_->LoadSynchronously(request_in, response_out, error_out, data_out,
                              encoded_data_length, encoded_body_length);
 
   // A message dispatched while synchronously fetching the resource
   // can bring about the cancellation of this load.
   if (!loader_)
     return;
+  int64_t decoded_body_length = data_out.size();
   if (error_out.reason) {
-    DidFail(error_out, encoded_data_length, encoded_body_length);
+    DidFail(error_out, encoded_data_length, encoded_body_length,
+            decoded_body_length);
     return;
   }
   DidReceiveResponse(response_out);
   if (!loader_)
     return;
   DCHECK_GE(response_out.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 (data_out.size()) {
     Context().DispatchDidReceiveData(resource_->Identifier(), data_out.Data(),
                                      data_out.size());
     resource_->SetResourceBuffer(data_out);
   }
   DidFinishLoading(MonotonicallyIncreasingTime(), encoded_data_length,
-                   encoded_body_length);
+                   encoded_body_length, decoded_body_length);
 }
 
 void ResourceLoader::Dispose() {
   loader_ = nullptr;
 }
 
 void ResourceLoader::ActivateCacheAwareLoadingIfNeeded(
     const ResourceRequest& request) {
   DCHECK(!is_cache_aware_loading_activated_);
 
@@ skipping 10 matching lines @@
     return;
 
   // Don't activate if cache policy is explicitly set.
   if (request.GetCachePolicy() != WebCachePolicy::kUseProtocolCachePolicy)
     return;
 
   is_cache_aware_loading_activated_ = true;
 }
 
 }  // namespace blink