Update NetLog to be thread safe.

chrome/browser/io_thread.h

 // 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.
 
 #ifndef CHROME_BROWSER_IO_THREAD_H_
 #define CHROME_BROWSER_IO_THREAD_H_
 #pragma once
 
 #include <set>
 
@@ skipping 21 matching lines @@
 class ProxyScriptFetcher;
 class URLSecurityManager;
 }  // namespace net
 
 class IOThread : public BrowserProcessSubThread {
  public:
   struct Globals {
     Globals();
     ~Globals();
 
-    scoped_ptr<ChromeNetLog> net_log;
     scoped_ptr<net::HostResolver> host_resolver;
     scoped_ptr<net::DnsRRResolver> dnsrr_resolver;
     scoped_ptr<net::HttpAuthHandlerFactory> http_auth_handler_factory;
     scoped_ptr<net::URLSecurityManager> url_security_manager;
     ChromeNetworkDelegate network_delegate;
   };
 
-  IOThread();
+  explicit IOThread(ChromeNetLog* net_log);

[eroman, 2010/11/16 17:51:14]

Please describe ownership model (i.e. net_log must outlive IOThread, or can be
NULL).

 
   virtual ~IOThread();
 
   // Can only be called on the IO thread.
   Globals* globals();
 
+  ChromeNetLog* net_log();
+
   // Initializes the network predictor, which induces DNS pre-resolution and/or
   // TCP/IP preconnections.  |prefetching_enabled| indicates whether or not DNS
   // prefetching should be enabled, and |preconnect_enabled| controls whether
   // TCP/IP preconnection is enabled.  This should be called by the UI thread.
   // It will post a task to the IO thread to perform the actual initialization.
   void 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,
@@ skipping 28 matching lines @@
       size_t max_speculative_parallel_resolves,
       const chrome_common_net::UrlList& startup_urls,
       ListValue* referral_list,
       bool preconnect_enabled);
 
   void ChangedToOnTheRecordOnIOThread();
 
   // These member variables are basically global, but their lifetimes are tied
   // to the IOThread.  IOThread owns them all, despite not using scoped_ptr.
   // This is because the destructor of IOThread runs on the wrong thread.  All
-  // member variables should be deleted in CleanUp(), except ChromeNetLog
-  // which is deleted later in CleanUpAfterMessageLoopDestruction().
+  // member variables should be deleted in CleanUp().
 
   // These member variables are initialized in Init() and do not change for the
   // lifetime of the IO thread.
 
   Globals* globals_;
 
-  // This variable is only meaningful during shutdown. It is used to defer
-  // deletion of the NetLog to CleanUpAfterMessageLoopDestruction() even
-  // though |globals_| is reset by CleanUp().
-  scoped_ptr<ChromeNetLog> deferred_net_log_to_delete_;
-
   // Observer that logs network changes to the ChromeNetLog.
   scoped_ptr<net::NetworkChangeNotifier::Observer> network_change_observer_;
 
   // These member variables are initialized by a task posted to the IO thread,
   // which gets posted by calling certain member functions of IOThread.
 
   // Note: we user explicit pointers rather than smart pointers to be more
   // explicit about destruction order, and ensure that there is no chance that
   // these observers would be used accidentally after we have begun to tear
   // down.
   chrome_browser_net::ConnectInterceptor* speculative_interceptor_;
   chrome_browser_net::Predictor* predictor_;
 
   // List of live ProxyScriptFetchers.
   ProxyScriptFetchers fetchers_;
 
+  // The NetLog is owned by the browser process, to allow logging from other
+  // threads during shutdown, but is used most frequently on the IOThread.
+  ChromeNetLog* net_log_;
+
   DISALLOW_COPY_AND_ASSIGN(IOThread);
 };
 
 #endif  // CHROME_BROWSER_IO_THREAD_H_