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 "base/command_line.h"
 #include "base/debug/leak_tracker.h"
 #include "base/logging.h"
 #include "base/metrics/field_trial.h"
@@ skipping 188 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() {}
 
-IOThread::IOThread()
-    : BrowserProcessSubThread(BrowserThread::IO),
+IOThread::IOThread(ChromeNetLog* net_log)
+    : net_log_(net_log),

[eroman, 2010/11/17 05:59:02]

I am not sure what the style guide says, but I think intuitively the
superclass's initializer should be first. (i.e. move this below
BrowserProcessSubThread()).

[mmenke, 2010/11/17 21:42:14]

Done.

+      BrowserProcessSubThread(BrowserThread::IO),
       globals_(NULL),
       speculative_interceptor_(NULL),
       predictor_(NULL) {}
 
 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 31 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()));
 }
 
 void IOThread::CleanUp() {
 #if defined(USE_NSS)
   net::ShutdownOCSP();
 #endif  // defined(USE_NSS)
 
@@ skipping 27 matching lines @@
   if (globals_->host_resolver->GetAsHostResolverImpl()) {
     globals_->host_resolver.get()->GetAsHostResolverImpl()->Shutdown();
   }
 
   // Break any cycles between the ProxyScriptFetcher and URLRequestContext.
   for (ProxyScriptFetchers::const_iterator it = fetchers_.begin();
        it != fetchers_.end(); ++it) {
     (*it)->Cancel();
   }
 
-  // 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 obsevers have
-  // run, but before the message loop itself is destroyed, we could safely
-  // combine the two cleanups.
-  deferred_net_log_to_delete_.reset();
   BrowserProcessSubThread::CleanUpAfterMessageLoopDestruction();
 
   // 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<URLRequest>::CheckForLeaks();
 }
 
@@ skipping 72 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_->passive_collector()->Clear();
 }