Adding histograms showing fraction of page load times

net/url_request/url_request_http_job.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 "net/url_request/url_request_http_job.h"
 
 #include "base/base_switches.h"
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/command_line.h"
@@ skipping 16 matching lines @@
 #include "net/base/network_delegate.h"
 #include "net/base/sdch_manager.h"
 #include "net/base/ssl_cert_request_info.h"
 #include "net/base/ssl_config_service.h"
 #include "net/cookies/cookie_monster.h"
 #include "net/http/http_request_headers.h"
 #include "net/http/http_response_headers.h"
 #include "net/http/http_response_info.h"
 #include "net/http/http_status_code.h"
 #include "net/http/http_transaction.h"
+#include "net/http/http_transaction_delegate.h"
 #include "net/http/http_transaction_factory.h"
 #include "net/http/http_util.h"
 #include "net/url_request/fraudulent_certificate_reporter.h"
 #include "net/url_request/url_request.h"
 #include "net/url_request/url_request_context.h"
 #include "net/url_request/url_request_error_job.h"
 #include "net/url_request/url_request_redirect_job.h"
 #include "net/url_request/url_request_throttler_header_adapter.h"
 #include "net/url_request/url_request_throttler_manager.h"
 
@@ skipping 20 matching lines @@
   // Method to allow us to reset filter context for a response that should have
   // been SDCH encoded when there is an update due to an explicit HTTP header.
   void ResetSdchResponseToFalse();
 
  private:
   URLRequestHttpJob* job_;
 
   DISALLOW_COPY_AND_ASSIGN(HttpFilterContext);
 };
 
+class URLRequestHttpJob::HttpTransactionDelegateImpl
+    : public HttpTransactionDelegate {
+ public:
+  HttpTransactionDelegateImpl(URLRequest* request)
+      : request_(request),
+        network_delegate_(request->context()->network_delegate())  {
+  }
+  virtual ~HttpTransactionDelegateImpl() {
+    OnDetachRequest();
+  }
+  void OnDetachRequest() {
+    if (request_ == NULL || network_delegate_ == NULL)
+      return;
+    network_delegate_->NotifyCacheWaitStateChange(
+        *request_,
+        NetworkDelegate::CACHE_WAIT_STATE_DONE);

[rvargas (doing something else), 2012/07/23 22:22:36]

This generates a notification when the first job goes away... what happens with
subsequent jobs for the same request?

[tburkard, 2012/07/24 01:03:12]

Excellent comment -- I was not aware that a request could have multiple jobs.  I
originally had this class keep track of how many cache actions were pending, and
then remove the appropriate amount.  Matt asked me to remove this and put that
logic into a class upstream.  It seems I have to put this back in, right?
On 2012/07/23 22:22:36, rvargas wrote:

[mmenke, 2012/07/24 01:21:25]

I actually thought about this, surprisingly ;).  We always orphan the old job
before creating the new one (Since we have to detach the request, to prevent
subsequent calls from the Job back to the request), so it should all work out
fine.

[rvargas (doing something else), 2012/07/24 03:10:38]

Isn't _STATE_DONE supposed to indicate that all processing with this request is
complete/aborted? It is weird to generate more start/stop notifications (for the
next job) after done is generated.

If we want that model then the name should be changed.

[tburkard, 2012/07/24 22:23:26]

Done.

+    request_ = NULL;
+  }
+  virtual void OnCacheActionStart() OVERRIDE {
+    if (request_ == NULL || network_delegate_ == NULL)
+      return;
+    network_delegate_->NotifyCacheWaitStateChange(
+        *request_,
+        NetworkDelegate::CACHE_WAIT_STATE_START);
+  }
+  virtual void OnCacheActionFinish() OVERRIDE {
+    if (request_ == NULL || network_delegate_ == NULL)
+      return;
+    network_delegate_->NotifyCacheWaitStateChange(
+        *request_,
+        NetworkDelegate::CACHE_WAIT_STATE_FINISH);
+  }
+ private:
+  URLRequest* request_;
+  NetworkDelegate* network_delegate_;
+};
+
 URLRequestHttpJob::HttpFilterContext::HttpFilterContext(URLRequestHttpJob* job)
     : job_(job) {
   DCHECK(job_);
 }
 
 URLRequestHttpJob::HttpFilterContext::~HttpFilterContext() {
 }
 
 bool URLRequestHttpJob::HttpFilterContext::GetMimeType(
     std::string* mime_type) const {
@@ skipping 84 matching lines @@
       done_(false),
       bytes_observed_in_packets_(0),
       request_time_snapshot_(),
       final_packet_time_(),
       ALLOW_THIS_IN_INITIALIZER_LIST(
           filter_context_(new HttpFilterContext(this))),
       ALLOW_THIS_IN_INITIALIZER_LIST(weak_factory_(this)),
       ALLOW_THIS_IN_INITIALIZER_LIST(on_headers_received_callback_(
           base::Bind(&URLRequestHttpJob::OnHeadersReceivedCallback,
                      base::Unretained(this)))),
-      awaiting_callback_(false) {
+      awaiting_callback_(false),
+      http_transaction_delegate_(new HttpTransactionDelegateImpl(request)) {
   URLRequestThrottlerManager* manager = request->context()->throttler_manager();
   if (manager)
     throttling_entry_ = manager->RegisterRequestUrl(request->url());
 
   ResetTimer();
 }
 
 void URLRequestHttpJob::NotifyHeadersComplete() {
   DCHECK(!response_info_);
 
@@ skipping 107 matching lines @@
   }
 
   if (transaction_.get()) {
     rv = transaction_->RestartWithAuth(auth_credentials_, start_callback_);
     auth_credentials_ = AuthCredentials();
   } else {
     DCHECK(request_->context());
     DCHECK(request_->context()->http_transaction_factory());
 
     rv = request_->context()->http_transaction_factory()->CreateTransaction(
-        &transaction_);
+        &transaction_, http_transaction_delegate_.get());
     if (rv == OK) {
       if (!throttling_entry_ ||
           !throttling_entry_->ShouldRejectRequest(*request_)) {
         rv = transaction_->Start(
             &request_info_, start_callback_, request_->net_log());
         start_time_ = base::TimeTicks::Now();
       } else {
         // Special error code for the exponential back-off module.
         rv = ERR_TEMPORARILY_THROTTLED;
       }
@@ skipping 1110 matching lines @@
   DCHECK(transaction_->GetResponseInfo());
   return override_response_headers_.get() ?
       override_response_headers_ :
       transaction_->GetResponseInfo()->headers;
 }
 
 void URLRequestHttpJob::NotifyURLRequestDestroyed() {
   awaiting_callback_ = false;
 }
 
+void URLRequestHttpJob::OnDetachRequest() {
+  http_transaction_delegate_->OnDetachRequest();
+}
+
 }  // namespace net