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 54 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);
 }
 
+enum ExpectedContentSize {
+  EQ_RESPONSE_BODY = 0,
+  EQ_RESPONSE_BODY_MT_EQ_BUFFER_SIZE = 1,
+  LT_RESPONSE_BODY = 2,
+  MT_RESPONSE_BODY = 3,
+  UNKNOWN = 4,
+  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();
+  if (expected_content_size >= 0) {

[mmenke, 2017/01/13 16:01:36]

Having ExpectedContentSize be an enum that's not a size is a bit confusing,
particularly when we have a local variable expected_content_size that is a size.

Maybe rename ExpectedContentSize to ExpectedContentSizeResult or
ExpectedContentSizeCategory or somesuch.

[maksims (do not use this acc), 2017/01/16 07:25:22]

Done.

+    // Compare response body size to expected content size.
+    if (expected_content_size == total_read_body_bytes_ &&
+        expected_content_size >= kBufferSize) {
+      UMA_HISTOGRAM_ENUMERATION(
+          "Net.ResourceLoader.ExpectedContentSize.CorrespondsBodySize",

[mmenke, 2017/01/13 16:01:36]

Suggest just replacing "ExpectedContentSize.CorrespondsBodySize" with whatever
we use for the above enumeration (Now that we only have one histogram, don't
need to subdivide it further).

[maksims (do not use this acc), 2017/01/16 07:25:22]

Done.

+          ExpectedContentSize::EQ_RESPONSE_BODY_MT_EQ_BUFFER_SIZE,
+          ExpectedContentSize::EXPECTED_CONTENT_MAX);

[mmenke, 2017/01/13 16:01:36]

You only need one UMA_HISTOGRAM_ENUMERATION call here.

ExpectedContentSize expected_size = ExpectedContentSize::UNKNOWN;
if (expected_content_size >= 0) {
  if (...) {
    expected_size = ...;
  } else {
    ...
  }
}
UMA_HISTOGRAM_ENUMERATION(...);

[maksims (do not use this acc), 2017/01/16 07:25:21]

Done.

+    } else if (expected_content_size == total_read_body_bytes_) {
+      UMA_HISTOGRAM_ENUMERATION(
+          "Net.ResourceLoader.ExpectedContentSize.CorrespondsBodySize",
+          ExpectedContentSize::EQ_RESPONSE_BODY,
+          ExpectedContentSize::EXPECTED_CONTENT_MAX);
+    } else if (expected_content_size < total_read_body_bytes_) {
+      UMA_HISTOGRAM_ENUMERATION(
+          "Net.ResourceLoader.ExpectedContentSize.CorrespondsBodySize",
+          ExpectedContentSize::LT_RESPONSE_BODY,
+          ExpectedContentSize::EXPECTED_CONTENT_MAX);
+    } else {
+      UMA_HISTOGRAM_ENUMERATION(
+          "Net.ResourceLoader.ExpectedContentSize.CorrespondsBodySize",
+          ExpectedContentSize::MT_RESPONSE_BODY,
+          ExpectedContentSize::EXPECTED_CONTENT_MAX);
+    }
+  } else {
+    UMA_HISTOGRAM_ENUMERATION(
+        "Net.ResourceLoader.ExpectedContentSize.CorrespondsBodySize",
+        ExpectedContentSize::UNKNOWN,
+        ExpectedContentSize::EXPECTED_CONTENT_MAX);
+  }
+  total_read_body_bytes_ = 0;

[mmenke, 2017/01/13 16:01:36]

Not needed.  This class is only used to read one response body before
destruction, to don't need to clear this.

[maksims (do not use this acc), 2017/01/16 07:25:21]

Done.

 }
 
 void AsyncResourceHandler::SendUploadProgress(int64_t current_position,
                                               int64_t total_size) {
   ResourceMessageFilter* filter = GetFilter();
   if (!filter)
     return;
   filter->Send(new ResourceMsg_UploadProgress(
       GetRequestID(), current_position, total_size));
 }
 
 }  // namespace content