Add request_id to HttpRequestInfo and pass it to the NetworkDelegate for events.

net/http/http_cache_transaction.cc

 // Copyright (c) 2010 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/http/http_cache_transaction.h"
 
 #include "build/build_config.h"
 
 #if defined(OS_POSIX)
 #include <unistd.h>
 #endif
 
 #include <string>
 
 #include "base/compiler_specific.h"
 #include "base/metrics/field_trial.h"
 #include "base/metrics/histogram.h"
 #include "base/ref_counted.h"
 #include "base/string_util.h"
 #include "base/time.h"
 #include "net/base/cert_status_flags.h"
 #include "net/base/io_buffer.h"
 #include "net/base/load_flags.h"
 #include "net/base/net_errors.h"
 #include "net/base/net_log.h"
+#include "net/base/network_delegate.h"
 #include "net/base/ssl_cert_request_info.h"
 #include "net/base/ssl_config_service.h"
 #include "net/disk_cache/disk_cache.h"
 #include "net/http/disk_cache_based_ssl_host_info.h"
+#include "net/http/http_network_session.h"
 #include "net/http/http_request_info.h"
 #include "net/http/http_response_headers.h"
 #include "net/http/http_transaction.h"
 #include "net/http/http_util.h"
 #include "net/http/partial_data.h"
 
 using base::Time;
 
 namespace net {
 
@@ skipping 482 matching lines @@
         DCHECK_EQ(OK, rv);
         rv = DoPartialHeadersReceived();
         break;
       case STATE_CACHE_READ_RESPONSE:
         DCHECK_EQ(OK, rv);
         rv = DoCacheReadResponse();
         break;
       case STATE_CACHE_READ_RESPONSE_COMPLETE:
         rv = DoCacheReadResponseComplete(rv);
         break;
+      case STATE_CACHE_BEFORE_WRITE_RESPONSE:
+        rv = DoCacheBeforeWriteResponse(rv);
+        break;
       case STATE_CACHE_WRITE_RESPONSE:
         DCHECK_EQ(OK, rv);
         rv = DoCacheWriteResponse();
         break;
       case STATE_CACHE_WRITE_TRUNCATED_RESPONSE:
         DCHECK_EQ(OK, rv);
         rv = DoCacheWriteTruncatedResponse();
         break;
       case STATE_CACHE_WRITE_RESPONSE_COMPLETE:
         rv = DoCacheWriteResponseComplete(rv);
@@ skipping 547 matching lines @@
   } else if (mode_ != NONE) {
     // We are about to return the headers for a byte-range request to the user,
     // so let's fix them.
     partial_->FixResponseHeaders(response_.headers, true);
   }
   return OK;
 }
 
 int HttpCache::Transaction::DoCacheReadResponse() {
   DCHECK(entry_);
+

[rvargas (doing something else), 2011/03/17 19:40:20]

nit: remove

[Matt Perry, 2011/03/22 21:11:43]

Done.

   next_state_ = STATE_CACHE_READ_RESPONSE_COMPLETE;
 
   io_buf_len_ = entry_->disk_entry->GetDataSize(kResponseInfoIndex);
   read_buf_ = new IOBuffer(io_buf_len_);
 
   net_log_.BeginEvent(NetLog::TYPE_HTTP_CACHE_READ_INFO, NULL);
   cache_callback_->AddRef();  // Balanced in DoCacheReadResponseComplete.
   return entry_->disk_entry->ReadData(kResponseInfoIndex, 0, read_buf_,
                                       io_buf_len_, cache_callback_);
 }
 
 int HttpCache::Transaction::DoCacheReadResponseComplete(int result) {
   cache_callback_->Release();  // Balance the AddRef from DoCacheReadResponse.
   net_log_.EndEventWithNetErrorCode(NetLog::TYPE_HTTP_CACHE_READ_INFO, result);
   if (result != io_buf_len_ ||
       !HttpCache::ParseResponseInfo(read_buf_->data(), io_buf_len_,
                                     &response_, &truncated_)) {
     DLOG(ERROR) << "ReadData failed: " << result;
     return ERR_CACHE_READ_FAILURE;
   }
 
+  next_state_ = STATE_CACHE_BEFORE_WRITE_RESPONSE;

[rvargas (doing something else), 2011/03/17 19:40:20]

This should be related to the actual action performed on that state. Maybe
STATE_NOTIFY_NETWORK_DELEGATE/COMPLETE or something like that.

[Matt Perry, 2011/03/22 21:11:43]

Done.

+
+  cache_callback_->AddRef();  // Balanced in DoCacheBeforeWriteResponse.

[rvargas (doing something else), 2011/03/17 19:40:20]

I don't think you want to use this callback. This one is a cancelable callback
meant to be used only by the disk cache. We also have a regular io_callback_
that doesn't require grabbing references.

[Matt Perry, 2011/03/22 21:11:43]

I need a cancelable callback since the network delegate isn't notified when the
Transaction is cancelled/deleted. The delegate calls its callback at some point
in the future, when I presume the Transaction is no longer guaranteed to be
alive.

+  if (cache_->GetSession()->network_delegate()) {
+    // TODO(mpcomplete): Does it make sense to pass request headers here? Where
+    // do we get them?

[rvargas (doing something else), 2011/03/17 19:40:20]

request_->extra_headers

[Matt Perry, 2011/03/22 21:11:43]

Done.

+    HttpRequestHeaders empty_headers;
+    if (cache_->GetSession()->network_delegate()->NotifyBeforeHttpRequest(
+            request_->request_id, &empty_headers, cache_callback_))
+      return ERR_IO_PENDING;
+  }
+
+  return OK;
+}
+
+int HttpCache::Transaction::DoCacheBeforeWriteResponse(int result) {
+  cache_callback_->Release();  // balanced in DoCacheReadResponseComplete
+
   // We now have access to the cache entry.
   //
   //  o if we are a reader for the transaction, then we can start reading the
   //    cache entry.
   //
   //  o if we can read or write, then we should check if the cache entry needs
   //    to be validated and then issue a network request if needed or just read
   //    from the cache if the cache entry is already valid.
   //
   //  o if we are set to UPDATE, then we are handling an externally
   //    conditionalized request (if-modified-since / if-none-match). We check
   //    if the request headers define a validation request.
   //
-  switch (mode_) {
-    case READ:
-      result = BeginCacheRead();
-      break;
-    case READ_WRITE:
-      result = BeginPartialCacheValidation();
-      break;
-    case UPDATE:
-      result = BeginExternallyConditionalizedRequest();
-      break;
-    case WRITE:
-    default:
-      NOTREACHED();
-      result = ERR_FAILED;
+  if (result == net::OK) {
+    switch (mode_) {
+      case READ:
+        result = BeginCacheRead();
+        break;
+      case READ_WRITE:
+        result = BeginPartialCacheValidation();
+        break;
+      case UPDATE:
+        result = BeginExternallyConditionalizedRequest();
+        break;
+      case WRITE:
+      default:
+        NOTREACHED();
+        result = ERR_FAILED;
+    }
   }
   return result;
 }
 
 int HttpCache::Transaction::DoCacheWriteResponse() {
   if (net_log_.IsLoggingAllEvents() && entry_)
     net_log_.BeginEvent(NetLog::TYPE_HTTP_CACHE_WRITE_INFO, NULL);
   return WriteResponseInfoToEntry(false);
 }
 
@@ skipping 777 matching lines @@
     next_state_ = STATE_START_PARTIAL_CACHE_VALIDATION;
   }
   return result;
 }
 
 void HttpCache::Transaction::OnIOComplete(int result) {
   DoLoop(result);
 }
 
 }  // namespace net