Cache certificate verification results in memory.

chrome_frame/metrics_service.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.
 
 
 //------------------------------------------------------------------------------
 // Description of the life cycle of a instance of MetricsService.
 //
 //  OVERVIEW
 //
@@ skipping 56 matching lines @@
 #include "chrome/installer/util/browser_distribution.h"
 #include "chrome/installer/util/chrome_frame_distribution.h"
 #include "chrome/installer/util/google_update_settings.h"
 #include "chrome_frame/bind_status_callback_impl.h"
 #include "chrome_frame/chrome_frame_delegate.h"
 #include "chrome_frame/crash_reporting/crash_metrics.h"
 #include "chrome_frame/html_utils.h"
 #include "chrome_frame/http_negotiate.h"
 #include "chrome_frame/utils.h"
 #include "net/base/capturing_net_log.h"
+#include "net/base/cert_verifier.h"
 #include "net/base/host_resolver.h"
 #include "net/base/ssl_config_service_defaults.h"
 #include "net/base/upload_data.h"
 #include "net/http/http_auth_handler_factory.h"
 #include "net/http/http_cache.h"
 #include "net/http/http_network_layer.h"
 #include "net/url_request/url_request_context.h"
 #include "net/url_request/url_request_status.h"
 
 using base::Time;
@@ skipping 12 matching lines @@
 
 Lock MetricsService::metrics_service_lock_;
 
 // Traits to create an instance of the ChromeFrame upload thread.
 struct UploadThreadInstanceTraits
     : public base::LeakyLazyInstanceTraits<base::Thread> {
   static base::Thread* New(void* instance) {
     // Use placement new to initialize our instance in our preallocated space.
     // The parenthesis is very important here to force POD type initialization.
     base::Thread* upload_thread =
-        new (instance) base::Thread("ChromeFrameUploadThread");
+        new(instance) base::Thread("ChromeFrameUploadThread");
     base::Thread::Options options;
     options.message_loop_type = MessageLoop::TYPE_IO;
     bool ret = upload_thread->StartWithOptions(options);
     if (!ret) {
       NOTREACHED() << "Failed to start upload thread";
     }
     return upload_thread;
   }
 };
 
@@ skipping 16 matching lines @@
  public:
   explicit ChromeFrameUploadRequestContext(MessageLoop* io_loop)
       : io_loop_(io_loop) {
     Initialize();
   }
 
   ~ChromeFrameUploadRequestContext() {
     DVLOG(1) << __FUNCTION__;
     delete http_transaction_factory_;
     delete http_auth_handler_factory_;
+    delete cert_verifier_;
+    delete host_resolver_;
   }
 
   void Initialize() {
     user_agent_ = http_utils::GetDefaultUserAgent();
     user_agent_ = http_utils::AddChromeFrameToUserAgentValue(
       user_agent_);
 
     host_resolver_ =
         net::CreateSystemHostResolver(net::HostResolver::kDefaultParallelism,
                                       NULL, NULL);
+    cert_verifier_ = new net::CertVerifier;
     net::ProxyConfigService* proxy_config_service =
         net::ProxyService::CreateSystemProxyConfigService(NULL, NULL);
     DCHECK(proxy_config_service);
 
     proxy_service_ = net::ProxyService::CreateUsingSystemProxyResolver(
         proxy_config_service, 0, NULL);
     DCHECK(proxy_service_);
 
     ssl_config_service_ = new net::SSLConfigServiceDefaults;
 
     url_security_manager_.reset(
         net::URLSecurityManager::Create(NULL, NULL));
 
     std::string csv_auth_schemes = "basic,digest,ntlm,negotiate";
     std::vector<std::string> supported_schemes;
     base::SplitString(csv_auth_schemes, ',', &supported_schemes);
 
     http_auth_handler_factory_ = net::HttpAuthHandlerRegistryFactory::Create(
         supported_schemes, url_security_manager_.get(), host_resolver_,
         std::string(), false, false);
 
     http_transaction_factory_ = new net::HttpCache(
         net::HttpNetworkLayer::CreateFactory(host_resolver_,
+                                             cert_verifier_,
                                              NULL /* dnsrr_resovler */,
                                              NULL /* dns_cert_checker*/,
                                              NULL /* ssl_host_info */,
                                              proxy_service_,
                                              ssl_config_service_,
                                              http_auth_handler_factory_,
                                              network_delegate_,
                                              NULL),
         net::HttpCache::DefaultBackend::InMemory(0));
   }
@@ skipping 415 matching lines @@
     version += "-F";
     if (!version_info.IsOfficialBuild())
       version.append("-devel");
     return version;
   } else {
     NOTREACHED() << "Unable to retrieve version string.";
   }
 
   return std::string();
 }