Add a "LoadLog*" parameter to transactions, hostresolver, clientsocketpool.

net/http/http_cache.cc

 // Copyright (c) 2006-2009 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.h"
 
 #include <algorithm>
 
 #include "base/compiler_specific.h"
 
@@ skipping 176 matching lines @@
             network_read_callback_(this, &Transaction::OnNetworkReadCompleted)),
         ALLOW_THIS_IN_INITIALIZER_LIST(
             cache_read_callback_(new CancelableCompletionCallback<Transaction>(
                 this, &Transaction::OnCacheReadCompleted))) {
   }
 
   // Clean up the transaction.
   virtual ~Transaction();
 
   // HttpTransaction methods:
-  virtual int Start(const HttpRequestInfo*, CompletionCallback*);
+  virtual int Start(LoadLog*, const HttpRequestInfo*, CompletionCallback*);
   virtual int RestartIgnoringLastError(CompletionCallback*);
   virtual int RestartWithCertificate(X509Certificate* client_cert,
                                      CompletionCallback* callback);
   virtual int RestartWithAuth(const std::wstring& username,
                               const std::wstring& password,
                               CompletionCallback* callback);
   virtual bool IsReadyToRestartForAuth();
   virtual int Read(IOBuffer* buf, int buf_len, CompletionCallback*);
   virtual const HttpResponseInfo* GetResponseInfo() const;
   virtual LoadState GetLoadState() const;
@@ skipping 41 matching lines @@
 
  private:
   // This is a helper function used to trigger a completion callback.  It may
   // only be called if callback_ is non-null.
   void DoCallback(int rv);
 
   // This will trigger the completion callback if appropriate.
   int HandleResult(int rv);
 
   // Sets request_ and fields derived from it.
-  void SetRequest(const HttpRequestInfo* request);
+  void SetRequest(LoadLog* load_log, const HttpRequestInfo* request);
 
   // Returns true if the request should be handled exclusively by the network
   // layer (skipping the cache entirely).
   bool ShouldPassThrough();
 
   // Returns true if we should force an end-to-end fetch.
   bool ShouldBypassCache();
 
   // Called to begin reading from the cache.  Returns network error code.
   int BeginCacheRead();
@@ skipping 88 matching lines @@
 
   // Called to signal completion of the network transaction's Start method:
   void OnNetworkInfoAvailable(int result);
 
   // Called to signal completion of the network transaction's Read method:
   void OnNetworkReadCompleted(int result);
 
   // Called to signal completion of the cache's ReadData method:
   void OnCacheReadCompleted(int result);
 
+  scoped_refptr<LoadLog> load_log_;
   const HttpRequestInfo* request_;
   scoped_ptr<HttpRequestInfo> custom_request_;
   // If extra_headers specified a "if-modified-since" or "if-none-match",
   // |external_validation_| contains the value of that header.
   ValidationHeader external_validation_;
   HttpCache* cache_;
   HttpCache::ActiveEntry* entry_;
   scoped_ptr<HttpTransaction> network_trans_;
   CompletionCallback* callback_;  // Consumer's callback.
   HttpResponseInfo response_;
@@ skipping 24 matching lines @@
 
   // If there is an outstanding callback, mark it as cancelled so running it
   // does nothing.
   cache_read_callback_->Cancel();
 
   // We could still have a cache read in progress, so we just null the cache_
   // pointer to signal that we are dead.  See OnCacheReadCompleted.
   cache_ = NULL;
 }
 
-int HttpCache::Transaction::Start(const HttpRequestInfo* request,
+int HttpCache::Transaction::Start(LoadLog* load_log,
+                                  const HttpRequestInfo* request,
                                   CompletionCallback* callback) {
   DCHECK(request);
   DCHECK(callback);
 
   // ensure that we only have one asynchronous call at a time.
   DCHECK(!callback_);
 
   if (revoked())
     return ERR_UNEXPECTED;
 
-  SetRequest(request);
+  SetRequest(load_log, request);
 
   int rv;
 
   if (!ShouldPassThrough()) {
     cache_key_ = cache_->GenerateCacheKey(request);
 
     // requested cache access mode
     if (effective_load_flags_ & LOAD_ONLY_FROM_CACHE) {
       mode_ = READ;
     } else if (effective_load_flags_ & LOAD_BYPASS_CACHE) {
@@ skipping 268 matching lines @@
   c->Run(rv);
 }
 
 int HttpCache::Transaction::HandleResult(int rv) {
   DCHECK(rv != ERR_IO_PENDING);
   if (callback_)
     DoCallback(rv);
   return rv;
 }
 
-void HttpCache::Transaction::SetRequest(const HttpRequestInfo* request) {
+void HttpCache::Transaction::SetRequest(LoadLog* load_log,
+                                        const HttpRequestInfo* request) {
+  load_log_ = load_log;
   request_ = request;
   effective_load_flags_ = request_->load_flags;
 
   switch (cache_->mode()) {
     case NORMAL:
       break;
     case RECORD:
       // When in record mode, we want to NEVER load from the cache.
       // The reason for this is beacuse we save the Set-Cookie headers
       // (intentionally).  If we read from the cache, we replay them
@@ skipping 248 matching lines @@
 }
 
 int HttpCache::Transaction::BeginNetworkRequest() {
   DCHECK(mode_ & WRITE || mode_ == NONE);
   DCHECK(!network_trans_.get());
 
   network_trans_.reset(cache_->network_layer_->CreateTransaction());
   if (!network_trans_.get())
     return net::ERR_CACHE_CANNOT_CREATE_NETWORK_TRANSACTION;
 
-  int rv = network_trans_->Start(request_, &network_info_callback_);
+  int rv = network_trans_->Start(load_log_, request_, &network_info_callback_);
   if (rv != ERR_IO_PENDING)
     OnNetworkInfoAvailable(rv);
   return rv;
 }
 
 int HttpCache::Transaction::RestartNetworkRequest() {
   DCHECK(mode_ & WRITE || mode_ == NONE);
   DCHECK(network_trans_.get());
 
   int rv = network_trans_->RestartIgnoringLastError(&network_info_callback_);
@@ skipping 1033 matching lines @@
       static_cast<net::HttpNetworkLayer*>(network_layer_.get());
   HttpNetworkSession* session = network->GetSession();
   if (session) {
     session->connection_pool()->CloseIdleSockets();
   }
 }
 
 //-----------------------------------------------------------------------------
 
 }  // namespace net