PluginList cleanup

content/browser/plugin_service.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 "content/browser/plugin_service.h"
 
 #include <vector>
 
 #include "base/command_line.h"
 #include "base/compiler_specific.h"
@@ skipping 305 matching lines @@
     int render_process_id,
     int render_view_id,
     const GURL& url,
     const std::string& mime_type,
     PluginProcessHost::Client* client) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
   webkit::npapi::WebPluginInfo info;
   bool found = GetPluginInfo(
       render_process_id, render_view_id, url, mime_type, &info, NULL);
   FilePath plugin_path;
-  if (found && webkit::npapi::IsPluginEnabled(info))
+  if (found)
     plugin_path = FilePath(info.path);
 
   // Now we jump back to the IO thread to finish opening the channel.
   BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE,
       NewRunnableMethod(
           this, &PluginService::FinishOpenChannelToPlugin,
           plugin_path, client));
 }
 
@@ skipping 11 matching lines @@
 
 bool PluginService::GetPluginInfo(int render_process_id,
                                   int render_view_id,
                                   const GURL& url,
                                   const std::string& mime_type,
                                   webkit::npapi::WebPluginInfo* info,
                                   std::string* actual_mime_type) {
   // GetPluginInfoArray may need to load the plugins, so we need to be
   // on the FILE thread.
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
-  bool allow_wildcard = true;
   {
     base::AutoLock auto_lock(overridden_plugins_lock_);
     for (size_t i = 0; i < overridden_plugins_.size(); ++i) {
       if (overridden_plugins_[i].render_process_id == render_process_id &&
           overridden_plugins_[i].render_view_id == render_view_id &&
           overridden_plugins_[i].url == url) {
         if (actual_mime_type)
           *actual_mime_type = mime_type;
         *info = overridden_plugins_[i].plugin;
         return true;
       }
     }
   }
-  return webkit::npapi::PluginList::Singleton()->GetPluginInfo(
-      url, mime_type, allow_wildcard, info, actual_mime_type);
+  bool allow_wildcard = true;
+  std::vector<webkit::npapi::WebPluginInfo> plugins;
+  std::vector<std::string> mime_types;
+  webkit::npapi::PluginList::Singleton()->GetPluginInfoArray(
+      url, mime_type, allow_wildcard, NULL, &plugins, &mime_types);
+  for (size_t i = 0; i < plugins.size(); ++i) {
+    if (webkit::npapi::IsPluginEnabled(plugins[i])) {
+      *info = plugins[i];
+      if (actual_mime_type)
+        *actual_mime_type = mime_types[i];
+      return true;
+    }
+  }
+  return false;
 }
 
 void PluginService::OnWaitableEventSignaled(
     base::WaitableEvent* waitable_event) {
 #if defined(OS_WIN)
   if (waitable_event == hkcu_event_.get()) {
     hkcu_key_.StartWatching();
   } else {
     hklm_key_.StartWatching();
   }
@@ skipping 103 matching lines @@
 #if defined(OS_POSIX) && !defined(OS_MACOSX)
 // static
 void PluginService::RegisterFilePathWatcher(
     FilePathWatcher *watcher,
     const FilePath& path,
     FilePathWatcher::Delegate* delegate) {
   bool result = watcher->Watch(path, delegate);
   DCHECK(result);
 }
 #endif