Add histogram to measure the read deferral on crosswebsite navigation

content/browser/loader/resource_loader.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/resource_loader.h"
 
 #include "base/command_line.h"
 #include "base/message_loop.h"
+#include "base/metrics/histogram.h"
 #include "base/time.h"
 #include "content/browser/child_process_security_policy_impl.h"
 #include "content/browser/loader/doomed_resource_handler.h"
 #include "content/browser/loader/resource_loader_delegate.h"
 #include "content/browser/loader/resource_request_info_impl.h"
 #include "content/browser/ssl/ssl_client_auth_handler.h"
 #include "content/browser/ssl/ssl_manager.h"
 #include "content/common/ssl_status_serialization.h"
 #include "content/public/browser/cert_store.h"
 #include "content/public/browser/resource_dispatcher_host_login_delegate.h"
@@ skipping 187 matching lines @@
 void ResourceLoader::Init(scoped_ptr<net::URLRequest> request,
                           scoped_ptr<ResourceHandler> handler,
                           ResourceLoaderDelegate* delegate,
                           scoped_ptr<net::ClientCertStore> client_cert_store) {
   deferred_stage_ = DEFERRED_NONE;
   request_ = request.Pass();
   handler_ = handler.Pass();
   delegate_ = delegate;
   last_upload_position_ = 0;
   waiting_for_upload_progress_ack_ = false;
+  compute_read_deferral_histogram_ = false;
   is_transferring_ = false;
   client_cert_store_ = client_cert_store.Pass();
 
   request_->set_delegate(this);
   handler_->SetController(this);
 }
 
 void ResourceLoader::OnReceivedRedirect(net::URLRequest* unused,
                                         const GURL& new_url,
                                         bool* defer) {
@@ skipping 129 matching lines @@
   }
 
   // We want to send a final upload progress message prior to sending the
   // response complete message even if we're waiting for an ack to to a
   // previous upload progress message.
   waiting_for_upload_progress_ack_ = false;
   ReportUploadProgress();
 
   CompleteResponseStarted();
 
-  if (is_deferred())
+  if (is_deferred()) {
+    compute_read_deferral_histogram_ = true;

[pasko, 2013/05/21 16:37:51]

I think reflecting the state rather than intention would be better:
"deferred_before_initial_resume_ = true;".

[James Simonsen, 2013/08/01 19:17:40]

I don't think you need this bool at all. Just check deferral_time_.is_null().

[clamy, 2013/08/05 14:33:44]

Done.

+    deferral_time_ = base::TimeTicks::Now();

[pasko, 2013/05/21 16:37:51]

this would sound more logical with the name response_started_time_

     return;
+  }
 
   if (request_->status().is_success()) {
     StartReading(false);  // Read the first chunk.
   } else {
     ResponseCompleted();
   }
 }
 
 void ResourceLoader::OnReadCompleted(net::URLRequest* unused, int bytes_read) {
   DCHECK_EQ(request_.get(), unused);
@@ skipping 172 matching lines @@
            request_->ssl_info().security_bits == -1 &&
            !request_->ssl_info().connection_status);
   }
 
   delegate_->DidReceiveResponse(this);
 
   bool defer = false;
   if (!handler_->OnResponseStarted(info->GetRequestID(), response, &defer)) {
     Cancel();
   } else if (defer) {
     deferred_stage_ = DEFERRED_READ;  // Read first chunk when resumed.

[James Simonsen, 2013/08/01 19:17:40]

Seems like it'd make more sense to set deferral_time_ here.

[clamy, 2013/08/05 14:33:44]

Done.

   }
 }
 
 void ResourceLoader::StartReading(bool is_continuation) {
   int bytes_read = 0;
   ReadMore(&bytes_read);
 
   // If IO is pending, wait for the URLRequest to call OnReadCompleted.
   if (request_->status().is_io_pending())
     return;
 
   if (!is_continuation || bytes_read <= 0) {
     OnReadCompleted(request_.get(), bytes_read);
   } else {
     // Else, trigger OnReadCompleted asynchronously to avoid starving the IO
     // thread in case the URLRequest can provide data synchronously.
     base::MessageLoop::current()->PostTask(
         FROM_HERE,
         base::Bind(&ResourceLoader::OnReadCompleted,
                    weak_ptr_factory_.GetWeakPtr(),
                    request_.get(),
                    bytes_read));
   }
 }
 
 void ResourceLoader::ResumeReading() {
   DCHECK(!is_deferred());
 
+  if (compute_read_deferral_histogram_) {
+    compute_read_deferral_histogram_ = false;
+    UMA_HISTOGRAM_TIMES("Net.ResourceLoader.ReadDeferral",

[pasko, 2013/05/21 16:37:51]

please also add a pairing change in:
tools/metrics/histograms/histograms.xml

Would require adding jar@ as reviewer for that part.

+                        base::TimeTicks::Now() - deferral_time_);
+  }
   if (request_->status().is_success()) {
     StartReading(false);  // Read the next chunk (OK to complete synchronously).
   } else {
     ResponseCompleted();
   }
 }
 
 void ResourceLoader::ReadMore(int* bytes_read) {
   ResourceRequestInfoImpl* info = GetRequestInfo();
   DCHECK(!is_deferred());
@@ skipping 51 matching lines @@
     // we resume.
     deferred_stage_ = DEFERRED_FINISH;
   }
 }
 
 void ResourceLoader::CallDidFinishLoading() {
   delegate_->DidFinishLoading(this);
 }
 
 }  // namespace content