Add the ability for DevTools to wrap network transactions.

net/http/http_cache.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/http/http_cache.h"
 
 #include <algorithm>
 
 #include "base/compiler_specific.h"
 
@@ skipping 273 matching lines @@
   HttpCache* const http_cache_;
 };
 
 //-----------------------------------------------------------------------------
 HttpCache::HttpCache(const net::HttpNetworkSession::Params& params,
                      BackendFactory* backend_factory)
     : net_log_(params.net_log),
       backend_factory_(backend_factory),
       building_backend_(false),
       mode_(NORMAL),
-      quic_server_info_factory_(params.enable_quic_persist_server_info ?
-          new QuicServerInfoFactoryAdaptor(this) : NULL),
       network_layer_(new HttpNetworkLayer(new HttpNetworkSession(params))) {
-  HttpNetworkSession* session = network_layer_->GetSession();
-  session->quic_stream_factory()->set_quic_server_info_factory(
-      quic_server_info_factory_.get());
+  SetupNetworkSession(network_layer_->GetSession());
 }
 
 
 // This call doesn't change the shared |session|'s QuicServerInfoFactory because
 // |session| is shared.
 HttpCache::HttpCache(HttpNetworkSession* session,
                      BackendFactory* backend_factory)
     : net_log_(session->net_log()),
       backend_factory_(backend_factory),
       building_backend_(false),
       mode_(NORMAL),
       network_layer_(new HttpNetworkLayer(session)) {
 }
 
 HttpCache::HttpCache(HttpTransactionFactory* network_layer,
                      NetLog* net_log,
-                     BackendFactory* backend_factory)
+                     BackendFactory* backend_factory,
+                     bool setup_network_session)
     : net_log_(net_log),
       backend_factory_(backend_factory),
       building_backend_(false),
       mode_(NORMAL),
       network_layer_(network_layer) {
+  if (setup_network_session)
+    SetupNetworkSession(network_layer_->GetSession());
 }
 
 HttpCache::~HttpCache() {
   // If we have any active entries remaining, then we need to deactivate them.
   // We may have some pending calls to OnProcessPendingQueue, but since those
   // won't run (due to our destruction), we can simply ignore the corresponding
   // will_process_pending_queue flag.
   while (!active_entries_.empty()) {
     ActiveEntry* entry = active_entries_.begin()->second;
     entry->will_process_pending_queue = false;
@@ skipping 661 matching lines @@
   for (; it != pending_queue.end(); ++it) {
     if ((*it)->Matches(trans)) {
       delete *it;
       pending_queue.erase(it);
       return true;
     }
   }
   return false;
 }
 
+void HttpCache::SetupNetworkSession(HttpNetworkSession* session) {
+  if (session->params().enable_quic_persist_server_info) {

[rvargas (doing something else), 2014/04/29 23:40:45]

couldn't we use this condition to avoid having an explicit bool on the
constructor?

[eustas, 2014/05/07 13:47:17]

Unfortunately, this condition doesn't (and shouldn't) change between HttpCache
instantiations.

I'll add supplimential method to QuicStreamFactory instead.

+    DCHECK(!quic_server_info_factory_.get());

[rvargas (doing something else), 2014/04/29 23:40:45]

nit: shouldn't need get() here

[eustas, 2014/05/07 13:47:17]

Done.

+    quic_server_info_factory_.reset(new QuicServerInfoFactoryAdaptor(this));
+    session->quic_stream_factory()->set_quic_server_info_factory(
+        quic_server_info_factory_.get());
+  }
+}
+
 void HttpCache::ProcessPendingQueue(ActiveEntry* entry) {
   // Multiple readers may finish with an entry at once, so we want to batch up
   // calls to OnProcessPendingQueue.  This flag also tells us that we should
   // not delete the entry before OnProcessPendingQueue runs.
   if (entry->will_process_pending_queue)
     return;
   entry->will_process_pending_queue = true;
 
   base::MessageLoop::current()->PostTask(
       FROM_HERE,
@@ skipping 160 matching lines @@
     building_backend_ = false;
     DeletePendingOp(pending_op);
   }
 
   // The cache may be gone when we return from the callback.
   if (!item->DoCallback(result, disk_cache_.get()))
     item->NotifyTransaction(result, NULL);
 }
 
 }  // namespace net