Third patch in getting rid of caching MessageLoop pointers and always using C...

chrome/browser/memory_details.cc

 // Copyright (c) 2009 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/memory_details.h"
 
 #include "app/l10n_util.h"
 #include "base/file_version_info.h"
 #include "base/process_util.h"
 #include "base/string_util.h"
-#include "chrome/browser/browser_process.h"
 #include "chrome/browser/chrome_thread.h"
 #include "chrome/browser/renderer_host/backing_store_manager.h"
 #include "chrome/browser/renderer_host/render_process_host.h"
 #include "chrome/browser/tab_contents/navigation_entry.h"
 #include "chrome/browser/tab_contents/tab_contents.h"
 #include "chrome/common/child_process_host.h"
 #include "chrome/common/url_constants.h"
 #include "grit/chromium_strings.h"
 
 #if defined(OS_LINUX)
 #include "chrome/browser/zygote_host_linux.h"
 #include "chrome/browser/renderer_host/render_sandbox_host_linux.h"
 #endif
 
 // About threading:
 //
 // This operation will hit no fewer than 3 threads.
 //
 // The ChildProcessInfo::Iterator can only be accessed from the IO thread.
 //
 // The RenderProcessHostIterator can only be accessed from the UI thread.
 //
 // This operation can take 30-100ms to complete.  We never want to have
 // one task run for that long on the UI or IO threads.  So, we run the
 // expensive parts of this operation over on the file thread.
 //
 
 void MemoryDetails::StartFetch() {
-  ui_loop_ = MessageLoop::current();
-
-  DCHECK(ui_loop_ != g_browser_process->io_thread()->message_loop());
-  DCHECK(ui_loop_ != g_browser_process->file_thread()->message_loop());
+  DCHECK(!ChromeThread::CurrentlyOn(ChromeThread::IO));
+  DCHECK(!ChromeThread::CurrentlyOn(ChromeThread::FILE));
 
   // In order to process this request, we need to use the plugin information.
   // However, plugin process information is only available from the IO thread.
-  g_browser_process->io_thread()->message_loop()->PostTask(FROM_HERE,
+  ChromeThread::PostTask(
+      ChromeThread::IO, FROM_HERE,
       NewRunnableMethod(this, &MemoryDetails::CollectChildInfoOnIOThread));
 }
 
 void MemoryDetails::CollectChildInfoOnIOThread() {
   DCHECK(ChromeThread::CurrentlyOn(ChromeThread::IO));
 
   std::vector<ProcessMemoryInformation> child_info;
 
   // Collect the list of child processes.
   for (ChildProcessHost::Iterator iter; !iter.Done(); ++iter) {
     ProcessMemoryInformation info;
     info.pid = base::GetProcId(iter->handle());
     if (!info.pid)
       continue;
 
     info.type = iter->type();
     info.titles.push_back(iter->name());
     child_info.push_back(info);
   }
 
   // Now go do expensive memory lookups from the file thread.
   ChromeThread::PostTask(
       ChromeThread::FILE, FROM_HERE,
       NewRunnableMethod(this, &MemoryDetails::CollectProcessData, child_info));
 }
 
 void MemoryDetails::CollectChildInfoOnUIThread() {
-  DCHECK(MessageLoop::current() == ui_loop_);
+  DCHECK(ChromeThread::CurrentlyOn(ChromeThread::UI));
 
 #if defined(OS_LINUX)
   const pid_t zygote_pid = Singleton<ZygoteHost>()->pid();
   const pid_t sandbox_helper_pid = Singleton<RenderSandboxHostLinux>()->pid();
 #endif
 
   ProcessData* const chrome_browser = ChromeBrowser();
   // Get more information about the process.
   for (size_t index = 0; index < chrome_browser->processes.size();
       index++) {
@@ skipping 131 matching lines @@
                           BackingStoreManager::MemorySize() / 1024);
 
   UMA_HISTOGRAM_COUNTS_100("Memory.ProcessCount",
       static_cast<int>(browser.processes.size()));
   UMA_HISTOGRAM_COUNTS_100("Memory.PluginProcessCount", plugin_count);
   UMA_HISTOGRAM_COUNTS_100("Memory.WorkerProcessCount", worker_count);
 
   int total_sample = static_cast<int>(aggregate_memory / 1000);
   UMA_HISTOGRAM_MEMORY_MB("Memory.Total", total_sample);
 }