Finish moving plugin probing out of process.

chrome/browser/ui/webui/flash_ui.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/ui/webui/flash_ui.h"
 
 #include <map>
 #include <string>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/callback_old.h"
 #include "base/i18n/time_formatting.h"
+#include "base/memory/weak_ptr.h"
 #include "base/string_number_conversions.h"
 #include "base/stringprintf.h"
 #include "base/threading/thread_restrictions.h"
 #include "base/timer.h"
 #include "base/utf_string_conversions.h"
 #include "base/values.h"
 #include "chrome/browser/crash_upload_list.h"
 #include "chrome/browser/plugin_prefs.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/ui/webui/chrome_web_ui_data_source.h"
 #include "chrome/browser/ui/webui/crashes_ui.h"
 #include "chrome/common/chrome_version_info.h"
 #include "chrome/common/url_constants.h"
 #include "content/browser/gpu/gpu_data_manager.h"
+#include "content/browser/plugin_service.h"
 #include "content/browser/tab_contents/tab_contents.h"
 #include "content/browser/user_metrics.h"
 #include "grit/browser_resources.h"
 #include "grit/chromium_strings.h"
 #include "grit/generated_resources.h"
 #include "grit/theme_resources.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "ui/base/resource/resource_bundle.h"
-#include "webkit/plugins/npapi/plugin_list.h"
 #include "webkit/plugins/webplugininfo.h"
 
 #if defined(OS_WIN)
 #include "base/win/windows_version.h"
 #endif
 
 namespace {
 
 ChromeWebUIDataSource* CreateFlashUIHTMLSource() {
   ChromeWebUIDataSource* source =
@@ skipping 27 matching lines @@
 
   // CrashUploadList::Delegate implementation.
   virtual void OnCrashListAvailable() OVERRIDE;
 
   // Callback for the "requestFlashInfo" message.
   void HandleRequestFlashInfo(const ListValue* args);
 
   // Callback for the GPU information update.
   void OnGpuInfoUpdate();
 
+  // Callback for the Flash plugin information.
+  void OnGotPlugins(const std::vector<webkit::WebPluginInfo>& plugins);
+
  private:
   // Called when we think we might have enough information to return data back
   // to the page.
   void MaybeRespondToPage();
 
   // In certain cases we might not get called back from the GPU process so we
   // set an upper limit on the time we wait. This function gets called when the
   // time has passed. This actually doesn't prevent the rest of the information
   // to appear later, the page will just reflow when more information becomes
   // available.
   void OnTimeout();
 
   // A timer to keep track of when the data fetching times out.
   base::OneShotTimer<FlashDOMHandler> timeout_;
 
   // GPU variables.
   GpuDataManager* gpu_data_manager_;
   Callback0::Type* gpu_info_update_callback_;
 
   // Crash list.
   scoped_refptr<CrashUploadList> upload_list_;
 
+  // Factory for the creating refs in callbacks.
+  base::WeakPtrFactory<FlashDOMHandler> weak_ptr_factory_;
+
   // Whether the list of all crashes is available.
   bool crash_list_available_;
   // Whether the page has requested data.
   bool page_has_requested_data_;
   // Whether the GPU data has been collected.
   bool has_gpu_info_;
+  // Whether the plugin information is ready.
+  bool has_plugin_info_;
 
   DISALLOW_COPY_AND_ASSIGN(FlashDOMHandler);
 };
 
 FlashDOMHandler::FlashDOMHandler()
-    : crash_list_available_(false),
+    : weak_ptr_factory_(ALLOW_THIS_IN_INITIALIZER_LIST(this)),
+      crash_list_available_(false),
       page_has_requested_data_(false),
-      has_gpu_info_(false) {
+      has_gpu_info_(false),
+      has_plugin_info_(false) {
   // Request Crash data asynchronously.
   upload_list_ = CrashUploadList::Create(this);
   upload_list_->LoadCrashListAsynchronously();
 
   // Watch for changes in GPUInfo.
   gpu_data_manager_ = GpuDataManager::GetInstance();
   gpu_info_update_callback_ =
       NewCallback(this, &FlashDOMHandler::OnGpuInfoUpdate);
   gpu_data_manager_->AddGpuInfoUpdateCallback(gpu_info_update_callback_);
 
   // Tell GpuDataManager it should have full GpuInfo. If the
   // GPU process has not run yet, this will trigger its launch.
   gpu_data_manager_->RequestCompleteGpuInfoIfNeeded();
 
   // GPU access might not be allowed at all, which will cause us not to get a
   // call back.
   if (!gpu_data_manager_->GpuAccessAllowed())
     OnGpuInfoUpdate();
 
+  PluginService::GetInstance()->GetPlugins(base::Bind(
+      &FlashDOMHandler::OnGotPlugins, weak_ptr_factory_.GetWeakPtr()));
+
   // And lastly, we fire off a timer to make sure we never get stuck at the
   // "Loading..." message.
   timeout_.Start(FROM_HERE, base::TimeDelta::FromMilliseconds(kTimeout),
                  this, &FlashDOMHandler::OnTimeout);
 }
 
 void FlashDOMHandler::RegisterMessages() {
   web_ui_->RegisterMessageCallback("requestFlashInfo",
       base::Bind(&FlashDOMHandler::HandleRequestFlashInfo,
                  base::Unretained(this)));
@@ skipping 18 matching lines @@
 void FlashDOMHandler::HandleRequestFlashInfo(const ListValue* args) {
   page_has_requested_data_ = true;
   MaybeRespondToPage();
 }
 
 void FlashDOMHandler::OnGpuInfoUpdate() {
   has_gpu_info_ = true;
   MaybeRespondToPage();
 }
 
+void FlashDOMHandler::OnGotPlugins(
+    const std::vector<webkit::WebPluginInfo>& plugins) {
+  has_plugin_info_ = true;
+  MaybeRespondToPage();
+}
+
 void FlashDOMHandler::OnTimeout() {
   // We don't set page_has_requested_data_ because that is guaranteed to appear
   // and we shouldn't be responding to the page before then.
   has_gpu_info_ = true;
   crash_list_available_ = true;
+  has_plugin_info_ = true;
   MaybeRespondToPage();
 }
 
 void FlashDOMHandler::MaybeRespondToPage() {
   // We don't reply until everything is ready. The page is showing a 'loading'
   // message until then. If you add criteria to this list, please update the
   // function OnTimeout() as well.
-  if (!page_has_requested_data_ || !crash_list_available_ || !has_gpu_info_)
+  if (!page_has_requested_data_ || !crash_list_available_ || !has_gpu_info_ ||
+      !has_plugin_info_) {
     return;
+  }
 
   timeout_.Stop();
 
   // This is code that runs only when the user types in about:flash. We don't
   // need to jump through hoops to offload this to the IO thread.
   base::ThreadRestrictions::ScopedAllowIO allow_io;
 
   // Obtain the Chrome version info.
   chrome::VersionInfo version_info;
 
@@ skipping 23 matching lines @@
   os_label += " SP" + base::IntToString(os->service_pack().major);
   if (os->service_pack().minor > 0)
     os_label += "." + base::IntToString(os->service_pack().minor);
   if (os->architecture() == base::win::OSInfo::X64_ARCHITECTURE)
     os_label += " 64 bit";
 #endif
   AddPair(list, l10n_util::GetStringUTF16(IDS_ABOUT_VERSION_OS), os_label);
 
   // Obtain the version of the Flash plugins.
   std::vector<webkit::WebPluginInfo> info_array;
-  webkit::npapi::PluginList::Singleton()->GetPluginInfoArray(
-      GURL(), "application/x-shockwave-flash", false, NULL, &info_array, NULL);
+  PluginService::GetInstance()->GetPluginInfoArray(
+      GURL(), "application/x-shockwave-flash", false, &info_array, NULL);
   string16 flash_version;
   if (info_array.empty()) {
     AddPair(list, ASCIIToUTF16("Flash plugin"), "Disabled");
   } else {
     PluginPrefs* plugin_prefs =
         PluginPrefs::GetForProfile(Profile::FromWebUI(web_ui_));
     for (size_t i = 0; i < info_array.size(); ++i) {
       if (plugin_prefs->IsPluginEnabled(info_array[i])) {
         flash_version = info_array[i].version + ASCIIToUTF16(" ") +
                         info_array[i].path.LossyDisplayName();
@@ skipping 98 matching lines @@
   // Set up the about:flash source.
   Profile* profile = Profile::FromBrowserContext(contents->browser_context());
   profile->GetChromeURLDataManager()->AddDataSource(CreateFlashUIHTMLSource());
 }
 
 // static
 RefCountedMemory* FlashUI::GetFaviconResourceBytes() {
   // Use the default icon for now.
   return NULL;
 }