Add checks to DEBUG mode that no instance of URLRequest or URLFetcher survive...

chrome/browser/browser_process_impl.cc

 // Copyright (c) 2006-2008 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/browser_process_impl.h"
 
 #include "app/l10n_util.h"
 #include "base/clipboard.h"
 #include "base/command_line.h"
 #include "base/path_service.h"
@@ skipping 40 matching lines @@
 //
 // Applications must initialize the COM library before they can call
 // COM library functions other than CoGetMalloc and memory allocation
 // functions, so this class initializes COM for those users.
 class BrowserProcessSubThread : public ChromeThread {
  public:
   explicit BrowserProcessSubThread(ChromeThread::ID identifier)
       : ChromeThread(identifier) {
   }
 
-  ~BrowserProcessSubThread() {
+  virtual ~BrowserProcessSubThread() {
     // We cannot rely on our base class to stop the thread since we want our
     // CleanUp function to run.
     Stop();
   }
 
  protected:
   virtual void Init() {
 #if defined(OS_WIN)
     // Initializes the COM library on the current thread.
     CoInitialize(NULL);
@@ skipping 13 matching lines @@
 #endif
   }
 
  private:
   // Each specialized thread has its own notification service.
   // Note: We don't use scoped_ptr because the destructor runs on the wrong
   // thread.
   NotificationService* notification_service_;
 };
 
+class IOThread : public BrowserProcessSubThread {
+ public:
+  IOThread() : BrowserProcessSubThread(ChromeThread::IO) {}
+
+  virtual ~IOThread() {
+    // We cannot rely on our base class to stop the thread since we want our
+    // CleanUp function to run.
+    Stop();
+  }
+
+ protected:
+  virtual void CleanUp() {
+    // URLFetcher and URLRequest instances must NOT outlive the IO thread.
+    base::LeakTracker<URLRequest>::CheckForLeaks();
+    base::LeakTracker<URLFetcher>::CheckForLeaks();
+
+    BrowserProcessSubThread::CleanUp();
+  }
+};
+
 }  // namespace
 
 BrowserProcessImpl::BrowserProcessImpl(const CommandLine& command_line)
     : created_resource_dispatcher_host_(false),
       created_metrics_service_(false),
       created_io_thread_(false),
       created_file_thread_(false),
       created_db_thread_(false),
       created_profile_manager_(false),
       created_local_state_(false),
@@ skipping 60 matching lines @@
   if (resource_dispatcher_host_.get()) {
     // Need to tell Safe Browsing Service that the IO thread is going away
     // since it cached a pointer to it.
     if (resource_dispatcher_host()->safe_browsing_service())
       resource_dispatcher_host()->safe_browsing_service()->ShutDown();
 
     // Cancel pending requests and prevent new requests.
     resource_dispatcher_host()->Shutdown();
   }
 
-  // Shutdown DNS prefetching now to ensure that network stack objects
-  // living on the IO thread get destroyed before the IO thread goes away.
-  if (io_thread_.get()) {
-    io_thread_->message_loop()->PostTask(FROM_HERE,
-        NewRunnableFunction(chrome_browser_net::EnsureDnsPrefetchShutdown));
-  }
-
 #if defined(OS_LINUX)
   // The IO thread must outlive the BACKGROUND_X11 thread.
   background_x11_thread_.reset();
 #endif
 
   // Need to stop io_thread_ before resource_dispatcher_host_, since
   // io_thread_ may still deref ResourceDispatcherHost and handle resource
   // request before going away.
-  io_thread_.reset();
+  ResetIOThread();
 
   // Clean up state that lives on the file_thread_ before it goes away.
   if (resource_dispatcher_host_.get()) {
     resource_dispatcher_host()->download_file_manager()->Shutdown();
     resource_dispatcher_host()->save_file_manager()->Shutdown();
   }
 
   // Need to stop the file_thread_ here to force it to process messages in its
   // message loop from the previous call to shutdown the DownloadFileManager,
   // SaveFileManager and SessionService.
@@ skipping 99 matching lines @@
 #if defined(OS_LINUX)
   // The lifetime of the BACKGROUND_X11 thread is a subset of the IO thread so
   // we start it now.
   scoped_ptr<base::Thread> background_x11_thread(
       new BrowserProcessSubThread(ChromeThread::BACKGROUND_X11));
   if (!background_x11_thread->Start())
     return;
   background_x11_thread_.swap(background_x11_thread);
 #endif
 
-  scoped_ptr<base::Thread> thread(
-      new BrowserProcessSubThread(ChromeThread::IO));
+  scoped_ptr<base::Thread> thread(new IOThread);
   base::Thread::Options options;
   options.message_loop_type = MessageLoop::TYPE_IO;
   if (!thread->StartWithOptions(options))
     return;
   io_thread_.swap(thread);
 }
 
+void BrowserProcessImpl::ResetIOThread() {
+  if (io_thread_.get()) {
+    io_thread_->message_loop()->PostTask(FROM_HERE,
+        NewRunnableFunction(CleanupOnIOThread));
+  }
+  io_thread_.reset();
+}
+
+// static
+void BrowserProcessImpl::CleanupOnIOThread() {
+  // Shutdown DNS prefetching now to ensure that network stack objects
+  // living on the IO thread get destroyed before the IO thread goes away.
+  chrome_browser_net::EnsureDnsPrefetchShutdown();
+  // TODO(eroman): can this be merged into IOThread::CleanUp() ?
+}
+
 void BrowserProcessImpl::CreateFileThread() {
   DCHECK(!created_file_thread_ && file_thread_.get() == NULL);
   created_file_thread_ = true;
 
   scoped_ptr<base::Thread> thread(
       new BrowserProcessSubThread(ChromeThread::FILE));
   base::Thread::Options options;
 #if defined(OS_WIN)
   // On Windows, the FILE thread needs to be have a UI message loop which pumps
   // messages in such a way that Google Update can communicate back to us.
@@ skipping 58 matching lines @@
   DCHECK(devtools_manager_.get() == NULL);
   created_devtools_manager_ = true;
   devtools_manager_ = new DevToolsManager();
 }
 
 void BrowserProcessImpl::CreateGoogleURLTracker() {
   DCHECK(google_url_tracker_.get() == NULL);
   scoped_ptr<GoogleURLTracker> google_url_tracker(new GoogleURLTracker);
   google_url_tracker_.swap(google_url_tracker);
 }