Simplify HttpCache/HttpNetworkLayer/HttpNetworkSession interaction.

chrome/browser/net/chrome_url_request_context.cc

 // Copyright (c) 2011 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 "chrome/browser/net/chrome_url_request_context.h"
 
 #include "base/command_line.h"
 #include "base/message_loop.h"
 #include "base/message_loop_proxy.h"
 #include "base/string_number_conversions.h"
@@ skipping 263 matching lines @@
 
   context->set_proxy_service(
       CreateProxyService(io_thread()->net_log(),
                          io_thread_globals->proxy_script_fetcher_context.get(),
                          proxy_config_service_.release(),
                          command_line));
 
   net::HttpCache::DefaultBackend* backend = new net::HttpCache::DefaultBackend(
       net::DISK_CACHE, disk_cache_path_, cache_size_,
       BrowserThread::GetMessageLoopProxyForThread(BrowserThread::CACHE));
-  net::HttpCache* cache =
-      new net::HttpCache(context->host_resolver(),
-                         context->cert_verifier(),
-                         context->dnsrr_resolver(),
-                         context->dns_cert_checker(),
-                         context->proxy_service(),
-                         context->ssl_config_service(),
-                         context->http_auth_handler_factory(),
-                         &io_thread_globals->network_delegate,
-                         io_thread()->net_log(),
-                         backend);
+  net::HttpCache* cache = new net::HttpCache(
+      context->host_resolver(),
+      context->cert_verifier(),
+      context->dnsrr_resolver(),
+      context->dns_cert_checker(),
+      context->proxy_service(),
+      context->ssl_config_service(),
+      context->http_auth_handler_factory(),
+      &io_thread_globals->network_delegate,
+      io_thread()->net_log(),
+      backend);
 
   bool record_mode = chrome::kRecordModeEnabled &&
                      command_line.HasSwitch(switches::kRecordMode);
   bool playback_mode = command_line.HasSwitch(switches::kPlaybackMode);
 
   if (record_mode || playback_mode) {
     // Don't use existing cookies and use an in-memory store.
     context->set_cookie_store(new net::CookieMonster(NULL,
         cookie_monster_delegate_));
     cache->set_mode(
@@ skipping 179 matching lines @@
       static_cast<ChromeCookiePolicy*>(main_context->cookie_policy()));
 
   // Create a media cache with default size.
   // TODO(hclam): make the maximum size of media cache configurable.
   net::HttpCache::DefaultBackend* backend = new net::HttpCache::DefaultBackend(
       net::MEDIA_CACHE, disk_cache_path_, cache_size_,
       BrowserThread::GetMessageLoopProxyForThread(BrowserThread::CACHE));
 
   net::HttpCache* main_cache =
       main_context->http_transaction_factory()->GetCache();
-  net::HttpCache* cache;
-  if (main_cache) {
-    // Try to reuse HttpNetworkSession in the main context, assuming that
-    // HttpTransactionFactory (network_layer()) of HttpCache is implemented
-    // by HttpNetworkLayer so we can reuse HttpNetworkSession within it. This
-    // assumption will be invalid if the original HttpCache is constructed with
-    // HttpCache(HttpTransactionFactory*, BackendFactory*) constructor.
-    net::HttpNetworkLayer* main_network_layer =
-        static_cast<net::HttpNetworkLayer*>(main_cache->network_layer());
-    cache = new net::HttpCache(main_network_layer->GetSession(), backend);
-    // TODO(eroman): Since this is poaching the session from the main
-    // context, it should hold a reference to that context preventing the
-    // session from getting deleted.
-  } else {
-    // If original HttpCache doesn't exist, simply construct one with a whole
-    // new set of network stack.
-    cache = new net::HttpCache(
-        io_thread_globals->host_resolver.get(),
-        io_thread_globals->cert_verifier.get(),
-        io_thread_globals->dnsrr_resolver.get(),
-        NULL /* dns_cert_checker */,
-        main_context->proxy_service(),
-        main_context->ssl_config_service(),
-        io_thread_globals->http_auth_handler_factory.get(),
-        &io_thread_globals->network_delegate,
-        io_thread()->net_log(),
-        backend);
-  }
-
+  net::HttpNetworkSession* network_session = main_cache->GetSession();

[wtc, 2011/01/28 01:51:23]

IMPORTANT: Why do we not need the null check for 'main_cache'
in the original code?

[willchan no longer on Chromium, 2011/01/28 06:12:07]

I will doublecheck with eroman tomorrow to make sure, but I'm pretty sure that
the main ChromeURLRequestContext is *ALWAYS* a HttpCache, so GetCache() will
always return it. I think the old code was probably back from a time when it
wasn't always guaranteed to be an HttpCache. In any case, all tests pass with
this, so I *think* it works. If we find it doesn't, I'll add it back and add a
test for it :)

+  net::HttpCache* cache = new net::HttpCache(network_session, backend);
   context->set_http_transaction_factory(cache);
   context->set_net_log(io_thread()->net_log());
 
   return context;
 }
 
 }  // namespace
 
 // ----------------------------------------------------------------------------
 // ChromeURLRequestContextGetter
@@ skipping 374 matching lines @@
   context->set_transport_security_state(
       transport_security_state_);
   context->set_ssl_config_service(ssl_config_service_);
   context->set_appcache_service(appcache_service_);
   context->set_database_tracker(database_tracker_);
   context->set_blob_storage_context(blob_storage_context_);
   context->set_file_system_context(file_system_context_);
   context->set_extension_info_map(extension_info_map_);
   context->set_prerender_manager(prerender_manager_);
 }