Add UMA histograms to AsyncResourceHandler to track content size.

content/browser/loader/async_resource_handler.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "content/browser/loader/async_resource_handler.h"
 
 #include <algorithm>
 #include <vector>
 
 #include "base/command_line.h"
@@ skipping 55 matching lines @@
   static bool did_init = false;
   if (did_init)
     return;
   did_init = true;
 
   GetNumericArg("resource-buffer-size", &kBufferSize);
   GetNumericArg("resource-buffer-min-allocation-size", &kMinAllocationSize);
   GetNumericArg("resource-buffer-max-allocation-size", &kMaxAllocationSize);
 }
 
+// This enum is used for logging a histogram and should not be reordered.
+enum ExpectedContentSizeResult {
+  EQ_RESPONSE_BODY = 0,
+  EQ_RESPONSE_BODY_GT_EQ_BUFFER_SIZE = 1,
+  GT_EQ_BUFFER_SIZE = 2,
+  LT_RESPONSE_BODY = 3,
+  GT_RESPONSE_BODY = 4,
+  UNKNOWN = 5,
+  EXPECTED_CONTENT_MAX,
+};
+
 }  // namespace
 
 // Used when kOptimizeLoadingIPCForSmallResources is enabled.
 // The instance hooks the buffer allocation of AsyncResourceHandler, and
 // determine if we should use SharedMemory or should inline the data into
 // the IPC message.
 class AsyncResourceHandler::InliningHelper {
  public:
 
   InliningHelper() {}
@@ skipping 99 matching lines @@
  public:
   DependentIOBuffer(ResourceBuffer* backing, char* memory)
       : net::WrappedIOBuffer(memory),
         backing_(backing) {
   }
  private:
   ~DependentIOBuffer() override {}
   scoped_refptr<ResourceBuffer> backing_;
 };
 
-AsyncResourceHandler::AsyncResourceHandler(
-    net::URLRequest* request,
-    ResourceDispatcherHostImpl* rdh)
+AsyncResourceHandler::AsyncResourceHandler(net::URLRequest* request,
+                                           ResourceDispatcherHostImpl* rdh)
     : ResourceHandler(request),
       ResourceMessageDelegate(request),
       rdh_(rdh),
       pending_data_count_(0),
       allocation_size_(0),
+      total_read_body_bytes_(0),
       did_defer_(false),
       has_checked_for_sufficient_resources_(false),
       sent_received_response_msg_(false),
       sent_data_buffer_msg_(false),
       inlining_helper_(new InliningHelper),
       reported_transfer_size_(0) {
   DCHECK(GetRequestInfo()->requester_info()->IsRenderer());
   InitializeResourceBufferConstants();
 }
 
@@ skipping 176 matching lines @@
   first_chunk_read_ = true;
 
   // Return early if InliningHelper handled the received data.
   if (inlining_helper_->SendInlinedDataIfApplicable(
           bytes_read, encoded_data_length, filter,
           GetRequestID()))
     return true;
 
   buffer_->ShrinkLastAllocation(bytes_read);
 
+  total_read_body_bytes_ += bytes_read;
+
   if (!sent_data_buffer_msg_) {
     base::SharedMemoryHandle handle = base::SharedMemory::DuplicateHandle(
         buffer_->GetSharedMemory().handle());
     if (!base::SharedMemory::IsHandleValid(handle))
       return false;
     filter->Send(new ResourceMsg_SetDataBuffer(
         GetRequestID(), handle, buffer_->GetSharedMemory().mapped_size(),
         filter->peer_pid()));
     sent_data_buffer_msg_ = true;
   }
@@ skipping 136 matching lines @@
     UMA_HISTOGRAM_CUSTOM_COUNTS(
         "Net.ResourceLoader.ResponseStartToEnd.LT_512kB",
         elapsed_time, 1, 100000, 100);
   } else {
     UMA_HISTOGRAM_CUSTOM_COUNTS(
         "Net.ResourceLoader.ResponseStartToEnd.Over_512kB",
         elapsed_time, 1, 100000, 100);
   }
 
   inlining_helper_->RecordHistogram(elapsed_time);
+
+  // Record if content size was known in advance.
+  int64_t expected_content_size = request()->GetExpectedContentSize();
+  ExpectedContentSizeResult expected_content_size_result =
+      ExpectedContentSizeResult::UNKNOWN;
+  if (expected_content_size >= 0) {
+    // Compare response body size to expected content size.
+    if (expected_content_size == total_read_body_bytes_ &&
+        expected_content_size >= kBufferSize) {
+      expected_content_size_result =
+          ExpectedContentSizeResult::EQ_RESPONSE_BODY_GT_EQ_BUFFER_SIZE;
+    } else if (expected_content_size >= kBufferSize) {
+      expected_content_size_result =
+          ExpectedContentSizeResult::GT_EQ_BUFFER_SIZE;
+    } else if (expected_content_size == total_read_body_bytes_) {
+      expected_content_size_result =
+          ExpectedContentSizeResult::EQ_RESPONSE_BODY;
+    } else if (expected_content_size < total_read_body_bytes_) {
+      expected_content_size_result =
+          ExpectedContentSizeResult::LT_RESPONSE_BODY;
+    } else {
+      expected_content_size_result =
+          ExpectedContentSizeResult::GT_RESPONSE_BODY;
+    }
+  }
+  UMA_HISTOGRAM_ENUMERATION("Net.ResourceLoader.ExpectedContentSizeResult",
+                            expected_content_size_result,
+                            ExpectedContentSizeResult::EXPECTED_CONTENT_MAX);
 }
 
 void AsyncResourceHandler::SendUploadProgress(
     const net::UploadProgress& progress) {
   ResourceMessageFilter* filter = GetFilter();
   if (!filter)
     return;
   filter->Send(new ResourceMsg_UploadProgress(
       GetRequestID(), progress.position(), progress.size()));
 }
 
 }  // namespace content