Make WebPluginInfo more generic

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 10 matching lines @@
 #include "content/browser/renderer_host/render_view_host.h"
 #include "content/browser/resource_context.h"
 #include "content/common/content_notification_types.h"
 #include "content/common/content_switches.h"
 #include "content/common/notification_service.h"
 #include "content/common/pepper_plugin_registry.h"
 #include "content/common/plugin_messages.h"
 #include "content/common/view_messages.h"
 #include "webkit/plugins/npapi/plugin_constants_win.h"
 #include "webkit/plugins/npapi/plugin_list.h"
-#include "webkit/plugins/npapi/webplugininfo.h"
+#include "webkit/plugins/webplugininfo.h"
 
 #if defined(OS_POSIX) && !defined(OS_MACOSX)
 using ::base::files::FilePathWatcher;
 #endif
 
 #if defined(OS_MACOSX)
 static void NotifyPluginsOfActivation() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
   for (BrowserChildProcessHost::Iterator iter(ChildProcessInfo::PLUGIN_PROCESS);
@@ skipping 162 matching lines @@
 }
 
 PluginProcessHost* PluginService::FindOrStartNpapiPluginProcess(
     const FilePath& plugin_path) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
   PluginProcessHost* plugin_host = FindNpapiPluginProcess(plugin_path);
   if (plugin_host)
     return plugin_host;
 
-  webkit::npapi::WebPluginInfo info;
+  webkit::WebPluginInfo info;
   if (!webkit::npapi::PluginList::Singleton()->GetPluginInfoByPath(
           plugin_path, &info)) {
     return NULL;
   }
 
   // This plugin isn't loaded by any plugin process, so create a new process.
   scoped_ptr<PluginProcessHost> new_host(new PluginProcessHost());
   if (!new_host->Init(info, ui_locale_)) {
     NOTREACHED();  // Init is not expected to fail.
     return NULL;
@@ skipping 87 matching lines @@
     client->OnChannelOpened(base::kNullProcessHandle, IPC::ChannelHandle());
 }
 
 void PluginService::GetAllowedPluginForOpenChannelToPlugin(
     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;
+  webkit::WebPluginInfo info;
   bool found = GetPluginInfo(
       render_process_id, render_view_id, url, mime_type, &info, NULL);
   FilePath plugin_path;
   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(
@@ skipping 10 matching lines @@
   if (plugin_host)
     plugin_host->OpenChannelToPlugin(client);
   else
     client->OnError();
 }
 
 bool PluginService::GetPluginInfo(int render_process_id,
                                   int render_view_id,
                                   const GURL& url,
                                   const std::string& mime_type,
-                                  webkit::npapi::WebPluginInfo* info,
+                                  webkit::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));
   {
     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;
       }
     }
   }
   bool allow_wildcard = true;
-  std::vector<webkit::npapi::WebPluginInfo> plugins;
+  std::vector<webkit::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])) {
+    if (webkit::IsPluginEnabled(plugins[i])) {
       *info = plugins[i];
       if (actual_mime_type)
         *actual_mime_type = mime_types[i];
       return true;
     }
   }
   return false;
 }
 
 void PluginService::OnWaitableEventSignaled(
@@ skipping 110 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