Make sure the "cancel leaked host resolver requests shutdown hack" gets run b...

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/leak_tracker.h"
 #include "base/logging.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/chrome_thread.h"
@@ skipping 126 matching lines @@
   globals_ = new Globals;
 
   globals_->net_log.reset(new ChromeNetLog());
   globals_->network_change_notifier.reset(
       net::NetworkChangeNotifier::CreateDefaultNetworkChangeNotifier());
   globals_->host_resolver =
       CreateGlobalHostResolver(globals_->network_change_notifier.get());
   globals_->http_auth_handler_factory.reset(CreateDefaultAuthHandlerFactory());
 }
 
-void IOThread::CleanUpAfterMessageLoopDestruction() {
+void IOThread::CleanUp() {
   // Not initialized in Init().  May not be initialized.
   if (dns_master_) {
     DCHECK(prefetch_observer_);
 
     dns_master_->Shutdown();
 
     // TODO(willchan): Stop reference counting DnsMaster.  It's owned by
     // IOThread now.
     dns_master_->Release();
     dns_master_ = NULL;
     chrome_browser_net::FreeDnsPrefetchResources();
   }
 
   // Not initialized in Init().  May not be initialized.
   if (prefetch_observer_) {
     globals_->host_resolver->RemoveObserver(prefetch_observer_);
     delete prefetch_observer_;
     prefetch_observer_ = NULL;
   }
 
   // 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;
 
   // URLFetcher and URLRequest instances must NOT outlive the IO thread.
   //
   // Strictly speaking, URLFetcher's CheckForLeaks() should be done on the
   // UI thread. However, since there _shouldn't_ be any instances left
   // at this point, it shouldn't be a race.
   //
   // We check URLFetcher first, since if it has leaked then an associated
   // URLRequest will also have leaked. However it is more useful to
   // crash showing the callstack of URLFetcher's allocation than its
   // URLRequest member.
   base::LeakTracker<URLFetcher>::CheckForLeaks();
   base::LeakTracker<URLRequest>::CheckForLeaks();
 
+  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();
 }
 
 net::HttpAuthHandlerFactory* IOThread::CreateDefaultAuthHandlerFactory() {
   net::HttpAuthFilterWhitelist* auth_filter = NULL;
 
   // Get the whitelist information from the command line, create an
   // HttpAuthFilterWhitelist, and attach it to the HttpAuthHandlerFactory.
   const CommandLine& command_line = *CommandLine::ForCurrentProcess();
 
@@ skipping 70 matching lines @@
     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();
 }