Update NetLog to be thread safe.

chrome/browser/io_thread.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 "chrome/browser/io_thread.h"
 
 #include <vector>
 
 #include "base/command_line.h"
 #include "base/debug/leak_tracker.h"
@@ skipping 196 matching lines @@
 // The IOThread object must outlive any tasks posted to the IO thread before the
 // Quit task.
 DISABLE_RUNNABLE_METHOD_REFCOUNT(IOThread);
 
 IOThread::Globals::Globals() {}
 
 IOThread::Globals::~Globals() {}
 
 // |local_state| is passed in explicitly in order to (1) reduce implicit
 // dependencies and (2) make IOThread more flexible for testing.
-IOThread::IOThread(PrefService* local_state)
+IOThread::IOThread(PrefService* local_state, ChromeNetLog* net_log)
     : BrowserProcessSubThread(BrowserThread::IO),
+      net_log_(net_log),
       globals_(NULL),
       speculative_interceptor_(NULL),
       predictor_(NULL) {
   // We call RegisterPrefs() here (instead of inside browser_prefs.cc) to make
   // sure that everything is initialized in the right order.
   RegisterPrefs(local_state);
   auth_schemes_ = local_state->GetString(prefs::kAuthSchemes);
   negotiate_disable_cname_lookup_ = local_state->GetBoolean(
       prefs::kDisableAuthNegotiateCnameLookup);
   negotiate_enable_port_ = local_state->GetBoolean(
       prefs::kEnableAuthNegotiatePort);
   auth_server_whitelist_ = local_state->GetString(prefs::kAuthServerWhitelist);
   auth_delegate_whitelist_ = local_state->GetString(
       prefs::kAuthNegotiateDelegateWhitelist);
   gssapi_library_name_ = local_state->GetString(prefs::kGSSAPILibraryName);
 }
 
 IOThread::~IOThread() {
   // We cannot rely on our base class to stop the thread since we want our
   // CleanUp function to run.
   Stop();
   DCHECK(!globals_);
 }
 
 IOThread::Globals* IOThread::globals() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   return globals_;
 }
 
+ChromeNetLog* IOThread::net_log() {
+  return net_log_;
+}
+
 void IOThread::InitNetworkPredictor(
     bool prefetching_enabled,
     base::TimeDelta max_dns_queue_delay,
     size_t max_speculative_parallel_resolves,
     const chrome_common_net::UrlList& startup_urls,
     ListValue* referral_list,
     bool preconnect_enabled) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   message_loop()->PostTask(
       FROM_HERE,
@@ skipping 55 matching lines @@
 
   DCHECK_EQ(MessageLoop::TYPE_IO, message_loop()->type());
 
 #if defined(USE_NSS)
   net::SetMessageLoopForOCSP();
 #endif  // defined(USE_NSS)
 
   DCHECK(!globals_);
   globals_ = new Globals;
 
-  globals_->net_log.reset(new ChromeNetLog());
-
   // Add an observer that will emit network change events to the ChromeNetLog.
   // Assuming NetworkChangeNotifier dispatches in FIFO order, we should be
   // logging the network change before other IO thread consumers respond to it.
   network_change_observer_.reset(
-      new LoggingNetworkChangeObserver(globals_->net_log.get()));
+      new LoggingNetworkChangeObserver(net_log_));
 
   globals_->host_resolver.reset(
-      CreateGlobalHostResolver(globals_->net_log.get()));
+      CreateGlobalHostResolver(net_log_));
   globals_->dnsrr_resolver.reset(new net::DnsRRResolver);
   globals_->http_auth_handler_factory.reset(CreateDefaultAuthHandlerFactory(
       globals_->host_resolver.get()));
 
   if (CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kEnablePagePrerender)) {
     prerender_interceptor_.reset(
         new chrome_browser_net::PrerenderInterceptor());
   }
 }
@@ skipping 66 matching lines @@
   delete speculative_interceptor_;
   speculative_interceptor_ = NULL;
 
   prerender_interceptor_.reset();
 
   // TODO(eroman): hack for http://crbug.com/15513
   if (globals_->host_resolver->GetAsHostResolverImpl()) {
     globals_->host_resolver.get()->GetAsHostResolverImpl()->Shutdown();
   }
 
-  // We will delete the NetLog as part of CleanUpAfterMessageLoopDestruction()
-  // in case any of the message loop destruction observers try to access it.
-  deferred_net_log_to_delete_.reset(globals_->net_log.release());
-
   delete globals_;
   globals_ = NULL;
 
   BrowserProcessSubThread::CleanUp();
 }
 
 void IOThread::CleanUpAfterMessageLoopDestruction() {
-  // TODO(eroman): get rid of this special case for 39723. If we could instead
-  // have a method that runs after the message loop destruction observers have
-  // run, but before the message loop itself is destroyed, we could safely
-  // combine the two cleanups.
-  deferred_net_log_to_delete_.reset();
-
   // This will delete the |notification_service_|.  Make sure it's done after
   // anything else can reference it.
   BrowserProcessSubThread::CleanUpAfterMessageLoopDestruction();
 
   // net::URLRequest instances must NOT outlive the IO thread.
   //
   // To allow for URLRequests to be deleted from
   // MessageLoop::DestructionObserver this check has to happen after CleanUp
   // (which runs before DestructionObservers).
   base::debug::LeakTracker<net::URLRequest>::CheckForLeaks();
@@ skipping 76 matching lines @@
   // in about:net-internals.
   if (globals_->host_resolver->GetAsHostResolverImpl()) {
     net::HostCache* host_cache =
         globals_->host_resolver.get()->GetAsHostResolverImpl()->cache();
     if (host_cache)
       host_cache->clear();
   }
   // Clear all of the passively logged data.
   // TODO(eroman): this is a bit heavy handed, really all we need to do is
   //               clear the data pertaining to off the record context.
-  globals_->net_log->passive_collector()->Clear();
+  net_log_->ClearAllPassivelyCapturedEvents();
 }