Finish moving plugin probing out of process.

chrome/browser/component_updater/npapi_flash_component_installer.cc

 // Copyright (c) 2011 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/component_updater/flash_component_installer.h"
 
+#include "base/bind.h"
 #include "base/base_paths.h"
 #include "base/compiler_specific.h"
 #include "base/file_path.h"
 #include "base/file_util.h"
 #include "base/logging.h"
 #include "base/path_service.h"
 #include "base/string_util.h"
 #include "base/values.h"
 #include "chrome/browser/component_updater/component_updater_service.h"
 #include "chrome/browser/plugin_prefs.h"
 #include "chrome/common/chrome_paths.h"
 #include "content/browser/browser_thread.h"
+#include "content/browser/plugin_service.h"
 #include "webkit/plugins/npapi/plugin_list.h"
+#include "webkit/plugins/webplugininfo.h"
 
 namespace {
 
 // CRX hash. The extension id is: immdilkhigodmjbnngapbehchmihabbg.
 const uint8 sha2_hash[] = {0x5c, 0x40, 0x30, 0xe3, 0x5d, 0x83, 0x2b, 0xd9,
                            0x7b, 0xa3, 0x69, 0xae, 0xbc, 0x7c, 0x5e, 0x5a,
                            0xef, 0xa5, 0xdf, 0x64, 0x6a, 0xe1, 0xc6, 0xdf,
                            0x23, 0x47, 0x30, 0x2a, 0xde, 0xae, 0x9d, 0xf7};
 
 // File name of the internal Flash plugin on different platforms.
@@ skipping 96 matching lines @@
   flash.pk_hash.assign(sha2_hash, &sha2_hash[sizeof(sha2_hash)]);
   if (cus->RegisterComponent(flash) != ComponentUpdateService::kOk) {
     NOTREACHED() << "Flash component registration fail";
   }
 }
 
 // The code in this function is only concerned about learning what flash plugin
 // chrome is using and what is its version. This will determine if we register
 // for component update or not. Read the comments on RegisterNPAPIFlashComponent
 // for more background.
-void StartFlashUpdateRegistration(ComponentUpdateService* cus) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
-
+void StartFlashUpdateRegistration(ComponentUpdateService* cus,
+                                  const std::vector<webkit::WebPluginInfo>&) {
   FilePath builtin_plugin_path;
   if (!PathService::Get(chrome::FILE_FLASH_PLUGIN, &builtin_plugin_path))
     return;
 
   FilePath updated_plugin_path =
       GetNPAPIFlashBaseDirectory().Append(kFlashPluginFileName);
 
-  webkit::npapi::PluginList* plugins = webkit::npapi::PluginList::Singleton();
+  PluginService* plugins = PluginService::GetInstance();
   webkit::WebPluginInfo plugin_info;
 
   if (plugins->GetPluginInfoByPath(updated_plugin_path, &plugin_info)) {
     // The updated plugin is newer. Since flash is used by pretty much every
     // webpage out there, odds are it is going to be loaded, which means
     // receiving an update is pointless since we can't swap them. You might
     // find this pessimistic. The way we get out of this situation is when
     // we update the whole product.
     DLOG(INFO) << "updated plugin overriding built-in flash";
     return;
   } else if (plugins->GetPluginInfoByPath(builtin_plugin_path, &plugin_info)) {
     // The built plugin is newer. Delete the updated plugin and register for
     // updates. This should be the normal case.
     file_util::Delete(GetNPAPIFlashBaseDirectory(), true);
   } else {
     // Strange installation. Log and abort registration.
     DLOG(WARNING) << "Strange flash npapi configuration";
     return;
   }
 
   BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
-      NewRunnableFunction(&FinishFlashUpdateRegistration, cus, plugin_info));
+      base::Bind(&FinishFlashUpdateRegistration, cus, plugin_info));
 }
 
 // Here is the general plan of action: we are going to update flash and we have
 // the following cases:
 // 1- The active flash is not the built-in flash (user override).
 // 2- The active flash is the built-in flash.
 // 3- The active flash is the one from the component updater.
 // In case 1 we do nothing. In cases 2 and 3 we need to compare versions
 // and if the higher version is:
 // case 2: remove the component update flash, register with component updater.
@@ skipping 19 matching lines @@
 // on the IO thread to learn which one won. Since we do it in a delayed task
 // probably somebody (unknowingly) will pay for the file IO, so usually get
 // the information for free.
 void RegisterNPAPIFlashComponent(ComponentUpdateService* cus) {
 #if defined(OS_WIN)
   webkit::npapi::PluginList* plugins = webkit::npapi::PluginList::Singleton();
   FilePath path = GetNPAPIFlashBaseDirectory().Append(kFlashPluginFileName);
   plugins->AddExtraPluginPath(path);
   plugins->RefreshPlugins();
 
-  BrowserThread::PostDelayedTask(BrowserThread::FILE, FROM_HERE,
-      NewRunnableFunction(&StartFlashUpdateRegistration, cus), 8000);
+  MessageLoop::current()->PostDelayedTask(FROM_HERE,
+      base::Bind(&PluginService::GetPlugins,
+                 base::Unretained(PluginService::GetInstance()),
+                 base::Bind(&StartFlashUpdateRegistration, cus)),
+      8000);
 #endif
 }