Simplify threading in browser thread by making only ChromeThread deal with di...

chrome/browser/plugin_service.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 "build/build_config.h"
 
 #include "chrome/browser/plugin_service.h"
 
 #include "base/command_line.h"
 #include "base/string_util.h"
@@ skipping 86 matching lines @@
 const FilePath& PluginService::GetChromePluginDataDir() {
   return chrome_plugin_data_dir_;
 }
 
 const std::wstring& PluginService::GetUILocale() {
   return ui_locale_;
 }
 
 PluginProcessHost* PluginService::FindPluginProcess(
     const FilePath& plugin_path) {
-  DCHECK(MessageLoop::current() ==
-         ChromeThread::GetMessageLoop(ChromeThread::IO));
+  DCHECK(ChromeThread::CurrentlyOn(ChromeThread::IO));
 
   if (plugin_path.value().empty()) {
     NOTREACHED() << "should only be called if we have a plugin to load";
     return NULL;
   }
 
   for (ChildProcessHost::Iterator iter(ChildProcessInfo::PLUGIN_PROCESS);
        !iter.Done(); ++iter) {
     PluginProcessHost* plugin = static_cast<PluginProcessHost*>(*iter);
     if (plugin->info().path == plugin_path)
       return plugin;
   }
 
   return NULL;
 }
 
 PluginProcessHost* PluginService::FindOrStartPluginProcess(
     const FilePath& plugin_path) {
-  DCHECK(MessageLoop::current() ==
-         ChromeThread::GetMessageLoop(ChromeThread::IO));
+  DCHECK(ChromeThread::CurrentlyOn(ChromeThread::IO));
 
   PluginProcessHost *plugin_host = FindPluginProcess(plugin_path);
   if (plugin_host)
     return plugin_host;
 
   WebPluginInfo info;
   if (!NPAPI::PluginList::Singleton()->GetPluginInfoByPath(
           plugin_path, &info)) {
     DCHECK(false);
     return NULL;
   }
 
   // This plugin isn't loaded by any plugin process, so create a new process.
   plugin_host = new PluginProcessHost();
   if (!plugin_host->Init(info, ui_locale_)) {
     DCHECK(false);  // Init is not expected to fail
     delete plugin_host;
     return NULL;
   }
 
   return plugin_host;
 }
 
 void PluginService::OpenChannelToPlugin(
     ResourceMessageFilter* renderer_msg_filter,
     const GURL& url,
     const std::string& mime_type,
     const std::wstring& locale,
     IPC::Message* reply_msg) {
-  DCHECK(MessageLoop::current() ==
-         ChromeThread::GetMessageLoop(ChromeThread::IO));
+  DCHECK(ChromeThread::CurrentlyOn(ChromeThread::IO));
   // We don't need a policy URL here because that was already checked by a
   // previous call to GetPluginPath.
   GURL policy_url;
   FilePath plugin_path = GetPluginPath(url, policy_url, mime_type, NULL);
   PluginProcessHost* plugin_host = FindOrStartPluginProcess(plugin_path);
   if (plugin_host) {
     plugin_host->OpenChannelToPlugin(renderer_msg_filter, mime_type, reply_msg);
   } else {
     PluginProcessHost::ReplyToRenderer(
         renderer_msg_filter, IPC::ChannelHandle(), WebPluginInfo(), reply_msg);
@@ skipping 89 matching lines @@
   PrivatePluginMap::iterator it = private_plugins_.find(plugin_path);
   if (it == private_plugins_.end())
     return true;  // This plugin is not private, so it's allowed everywhere.
 
   // We do a dumb compare of scheme and host, rather than using the domain
   // service, since we only care about this for extensions.
   const GURL& required_url = it->second;
   return (url.scheme() == required_url.scheme() &&
           url.host() == required_url.host());
 }