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_NOTIFY_BEFORE_SEND_HEADERS:
+        rv = DoCacheNotifyBeforeSendHeaders(rv);
+        break;
+      case STATE_CACHE_NOTIFY_BEFORE_SEND_HEADERS_COMPLETE:
+        rv = DoCacheNotifyBeforeSendHeadersComplete(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 560 matching lines @@
   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.
+  next_state_ = STATE_CACHE_NOTIFY_BEFORE_SEND_HEADERS;
+
   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;
   }
 
+  return OK;
+}
+
+int HttpCache::Transaction::DoCacheNotifyBeforeSendHeaders(int result) {

[rvargas (doing something else), 2011/03/23 00:54:35]

nit: no need for the argument.

[Matt Perry, 2011/03/24 00:11:25]

Done.

+  // Balanced in DoCacheNotifyBeforeSendHeadersComplete.
+  cache_callback_->AddRef();
+  next_state_ = STATE_CACHE_NOTIFY_BEFORE_SEND_HEADERS_COMPLETE;
+
+  if (cache_->GetSession()->network_delegate()) {
+    // TODO(mpcomplete): need to e able to modify these headers.

[rvargas (doing something else), 2011/03/23 00:54:35]

nit: to be able.

[Matt Perry, 2011/03/24 00:11:25]

Done.

+    HttpRequestHeaders headers = request_->extra_headers;
+    if (cache_->GetSession()->network_delegate()->NotifyBeforeSendHeaders(

[rvargas (doing something else), 2011/03/23 00:54:35]

I forgot to mention that it is possible to go through this code twice for the
same transaction, if there is a serious error after talking with the server (but
it should not be common at all).

I guess this is not a problem, given that you already send two notification for
the same request_id.

[Matt Perry, 2011/03/24 00:11:25]

We will actually only respond to the first notification. After that, we ignore
further onBeforeSendHeaders events for the same request_id. That might be bad,
for a privacy extension that relies on modifying the headers...

+            request_->request_id, &headers, cache_callback_))
+      return ERR_IO_PENDING;
+  }
+
+  return OK;
+}
+
+int HttpCache::Transaction::DoCacheNotifyBeforeSendHeadersComplete(int result) {

[rvargas (doing something else), 2011/03/23 00:54:35]

Result should be related to the return value of NotifyBeforeSendHeaders. In
fact, the general idea of a net callback is that the operation returns an int,
and the callback returns exactly the same value, but delayed.

[Matt Perry, 2011/03/24 00:11:25]

The result from the callback is either net::OK, or an error code indicating that
the request should be cancelled.

[rvargas (doing something else), 2011/03/24 18:16:02]

Just to double check, an error code here means that the request will be failed
with that error code

[Matt Perry, 2011/03/24 20:39:37]

Right.

+  cache_callback_->Release();  // Balanced in DoCacheNotifyBeforeSendHeaders.
+
   // 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