Move webplugininfo.h to content/public.

content/browser/plugin_service_impl.cc

 // Copyright (c) 2012 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_impl.h"
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/compiler_specific.h"
 #include "base/files/file_path.h"
@@ skipping 10 matching lines @@
 #include "content/browser/renderer_host/render_view_host_impl.h"
 #include "content/common/pepper_plugin_registry.h"
 #include "content/common/plugin_list.h"
 #include "content/common/view_messages.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/content_browser_client.h"
 #include "content/public/browser/plugin_service_filter.h"
 #include "content/public/browser/resource_context.h"
 #include "content/public/common/content_switches.h"
 #include "content/public/common/process_type.h"
+#include "content/public/common/webplugininfo.h"
 #include "webkit/plugins/plugin_constants.h"
-#include "webkit/plugins/webplugininfo.h"
 
 #if defined(OS_WIN)
 #include "content/common/plugin_constants_win.h"
 #include "ui/base/win/hwnd_util.h"
 #endif
 
 #if defined(OS_POSIX)
 #include "content/browser/plugin_loader_posix.h"
 #endif
 
@@ skipping 126 matching lines @@
   PluginList::Singleton()->set_will_load_plugins_callback(
       base::Bind(&WillLoadPluginsCallback, plugin_list_token_));
 
   RegisterPepperPlugins();
 
   // The --site-per-process flag enables an out-of-process iframes
   // prototype, which uses WebView for rendering. We need to register the MIME
   // type we use with the plugin, so the renderer can instantiate it.
   const CommandLine* command_line = CommandLine::ForCurrentProcess();
   if (command_line->HasSwitch(switches::kSitePerProcess)) {
-    webkit::WebPluginInfo webview_plugin(
+    WebPluginInfo webview_plugin(
         ASCIIToUTF16("WebView Tag"),
         base::FilePath(),
         ASCIIToUTF16("1.2.3.4"),
         ASCIIToUTF16("Browser Plugin."));
-    webview_plugin.type = webkit::WebPluginInfo::PLUGIN_TYPE_NPAPI;
-    webkit::WebPluginMimeType webview_plugin_mime_type;
+    webview_plugin.type = WebPluginInfo::PLUGIN_TYPE_NPAPI;
+    WebPluginMimeType webview_plugin_mime_type;
     webview_plugin_mime_type.mime_type = "application/browser-plugin";
     webview_plugin_mime_type.file_extensions.push_back("*");
     webview_plugin.mime_types.push_back(webview_plugin_mime_type);
     RegisterInternalPlugin(webview_plugin, true);
   }
 
   // Load any specified on the command line as well.
   base::FilePath path =
       command_line->GetSwitchValuePath(switches::kLoadPlugin);
   if (!path.empty())
@@ skipping 99 matching lines @@
     const base::FilePath& plugin_path) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
   if (filter_ && !filter_->CanLoadPlugin(render_process_id, plugin_path))
     return NULL;
 
   PluginProcessHost* plugin_host = FindNpapiPluginProcess(plugin_path);
   if (plugin_host)
     return plugin_host;
 
-  webkit::WebPluginInfo info;
+  WebPluginInfo info;
   if (!GetPluginInfoByPath(plugin_path, &info)) {
     return NULL;
   }
 
   // Record when NPAPI Flash process is started for the first time.
   static bool counted = false;
   if (!counted && UTF16ToUTF8(info.name) == kFlashPluginName) {
     counted = true;
     UMA_HISTOGRAM_ENUMERATION("Plugin.FlashUsage",
                               START_NPAPI_FLASH_AT_LEAST_ONCE,
@@ skipping 125 matching lines @@
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   DCHECK(ContainsKey(pending_plugin_clients_, client));
   pending_plugin_clients_.erase(client);
 }
 
 void PluginServiceImpl::ForwardGetAllowedPluginForOpenChannelToPlugin(
     const PluginServiceFilterParams& params,
     const GURL& url,
     const std::string& mime_type,
     PluginProcessHost::Client* client,
-    const std::vector<webkit::WebPluginInfo>&) {
+    const std::vector<WebPluginInfo>&) {
   GetAllowedPluginForOpenChannelToPlugin(params.render_process_id,
       params.render_view_id, url, params.page_url, mime_type, client,
       params.resource_context);
 }
 
 void PluginServiceImpl::GetAllowedPluginForOpenChannelToPlugin(
     int render_process_id,
     int render_view_id,
     const GURL& url,
     const GURL& page_url,
     const std::string& mime_type,
     PluginProcessHost::Client* client,
     ResourceContext* resource_context) {
-  webkit::WebPluginInfo info;
+  WebPluginInfo info;
   bool allow_wildcard = true;
   bool found = GetPluginInfo(
       render_process_id, render_view_id, resource_context,
       url, page_url, mime_type, allow_wildcard,
       NULL, &info, NULL);
   base::FilePath plugin_path;
   if (found)
     plugin_path = info.path;
 
   // Now we jump back to the IO thread to finish opening the channel.
@@ skipping 24 matching lines @@
     plugin_host->OpenChannelToPlugin(client);
   } else {
     client->OnError();
   }
 }
 
 bool PluginServiceImpl::GetPluginInfoArray(
     const GURL& url,
     const std::string& mime_type,
     bool allow_wildcard,
-    std::vector<webkit::WebPluginInfo>* plugins,
+    std::vector<WebPluginInfo>* plugins,
     std::vector<std::string>* actual_mime_types) {
   bool use_stale = false;
   PluginList::Singleton()->GetPluginInfoArray(
       url, mime_type, allow_wildcard, &use_stale, NPAPIPluginsSupported(),
       plugins, actual_mime_types);
   return use_stale;
 }
 
 bool PluginServiceImpl::GetPluginInfo(int render_process_id,
                                       int render_view_id,
                                       ResourceContext* context,
                                       const GURL& url,
                                       const GURL& page_url,
                                       const std::string& mime_type,
                                       bool allow_wildcard,
                                       bool* is_stale,
-                                      webkit::WebPluginInfo* info,
+                                      WebPluginInfo* info,
                                       std::string* actual_mime_type) {
-  std::vector<webkit::WebPluginInfo> plugins;
+  std::vector<WebPluginInfo> plugins;
   std::vector<std::string> mime_types;
   bool stale = GetPluginInfoArray(
       url, mime_type, allow_wildcard, &plugins, &mime_types);
   if (is_stale)
     *is_stale = stale;
 
   for (size_t i = 0; i < plugins.size(); ++i) {
     if (!filter_ || filter_->IsPluginAvailable(render_process_id,
                                                render_view_id,
                                                context,
                                                url,
                                                page_url,
                                                &plugins[i])) {
       *info = plugins[i];
       if (actual_mime_type)
         *actual_mime_type = mime_types[i];
       return true;
     }
   }
   return false;
 }
 
 bool PluginServiceImpl::GetPluginInfoByPath(const base::FilePath& plugin_path,
-                                            webkit::WebPluginInfo* info) {
-  std::vector<webkit::WebPluginInfo> plugins;
+                                            WebPluginInfo* info) {
+  std::vector<WebPluginInfo> plugins;
   PluginList::Singleton()->GetPluginsNoRefresh(&plugins);
 
-  for (std::vector<webkit::WebPluginInfo>::iterator it = plugins.begin();
+  for (std::vector<WebPluginInfo>::iterator it = plugins.begin();
        it != plugins.end();
        ++it) {
     if (it->path == plugin_path) {
       *info = *it;
       return true;
     }
   }
 
   return false;
 }
 
 string16 PluginServiceImpl::GetPluginDisplayNameByPath(
     const base::FilePath& path) {
   string16 plugin_name = path.LossyDisplayName();
-  webkit::WebPluginInfo info;
+  WebPluginInfo info;
   if (PluginService::GetInstance()->GetPluginInfoByPath(path, &info) &&
       !info.name.empty()) {
     plugin_name = info.name;
 #if defined(OS_MACOSX)
     // Many plugins on the Mac have .plugin in the actual name, which looks
     // terrible, so look for that and strip it off if present.
     const std::string kPluginExtension = ".plugin";
     if (EndsWith(plugin_name, ASCIIToUTF16(kPluginExtension), true))
       plugin_name.erase(plugin_name.length() - kPluginExtension.length());
 #endif  // OS_MACOSX
@@ skipping 10 matching lines @@
         PostSequencedWorkerTaskWithShutdownBehavior(
             plugin_list_token_,
             FROM_HERE,
             base::Bind(&PluginServiceImpl::GetPluginsInternal,
                        base::Unretained(this),
                        target_loop, callback),
         base::SequencedWorkerPool::SKIP_ON_SHUTDOWN);
     return;
   }
 #if defined(OS_POSIX)
-  std::vector<webkit::WebPluginInfo> cached_plugins;
+  std::vector<WebPluginInfo> cached_plugins;
   if (PluginList::Singleton()->GetPluginsNoRefresh(&cached_plugins)) {
     // Can't assume the caller is reentrant.
     target_loop->PostTask(FROM_HERE,
         base::Bind(callback, cached_plugins));
   } else {
     // If we switch back to loading plugins in process, then we need to make
     // sure g_thread_init() gets called since plugins may call glib at load.
     if (!plugin_loader_.get())
       plugin_loader_ = new PluginLoaderPosix;
     BrowserThread::PostTask(BrowserThread::IO, FROM_HERE,
         base::Bind(&PluginLoaderPosix::LoadPlugins, plugin_loader_,
                    target_loop, callback));
   }
 #else
   NOTREACHED();
 #endif
 }
 
 void PluginServiceImpl::GetPluginsInternal(
      base::MessageLoopProxy* target_loop,
      const PluginService::GetPluginsCallback& callback) {
   DCHECK(BrowserThread::GetBlockingPool()->IsRunningSequenceOnCurrentThread(
       plugin_list_token_));
 
-  std::vector<webkit::WebPluginInfo> plugins;
+  std::vector<WebPluginInfo> plugins;
   PluginList::Singleton()->GetPlugins(&plugins, NPAPIPluginsSupported());
 
   target_loop->PostTask(FROM_HERE,
       base::Bind(callback, plugins));
 }
 
 void PluginServiceImpl::OnWaitableEventSignaled(
     base::WaitableEvent* waitable_event) {
 #if defined(OS_WIN)
   if (waitable_event == hkcu_event_) {
@@ skipping 28 matching lines @@
       break;
     }
   }
   if (info)
     return info;
   // We did not find the plugin in our list. But wait! the plugin can also
   // be a latecomer, as it happens with pepper flash. This information
   // can be obtained from the PluginList singleton and we can use it to
   // construct it and add it to the list. This same deal needs to be done
   // in the renderer side in PepperPluginRegistry.
-  webkit::WebPluginInfo webplugin_info;
+  WebPluginInfo webplugin_info;
   if (!GetPluginInfoByPath(plugin_path, &webplugin_info))
     return NULL;
   PepperPluginInfo new_pepper_info;
   if (!MakePepperPluginInfo(webplugin_info, &new_pepper_info))
     return NULL;
   ppapi_plugins_.push_back(new_pepper_info);
   return &ppapi_plugins_[ppapi_plugins_.size() - 1];
 }
 
 #if defined(OS_POSIX) && !defined(OS_OPENBSD) && !defined(OS_ANDROID)
@@ skipping 76 matching lines @@
 
 void PluginServiceImpl::RemoveExtraPluginPath(const base::FilePath& path) {
   PluginList::Singleton()->RemoveExtraPluginPath(path);
 }
 
 void PluginServiceImpl::AddExtraPluginDir(const base::FilePath& path) {
   PluginList::Singleton()->AddExtraPluginDir(path);
 }
 
 void PluginServiceImpl::RegisterInternalPlugin(
-    const webkit::WebPluginInfo& info,
+    const WebPluginInfo& info,
     bool add_at_beginning) {
   if (!NPAPIPluginsSupported() &&
-      info.type == webkit::WebPluginInfo::PLUGIN_TYPE_NPAPI) {
+      info.type == WebPluginInfo::PLUGIN_TYPE_NPAPI) {
     DLOG(INFO) << "Don't register NPAPI plugins when they're not supported";
     return;
   }
   PluginList::Singleton()->RegisterInternalPlugin(info, add_at_beginning);
 }
 
 void PluginServiceImpl::UnregisterInternalPlugin(const base::FilePath& path) {
   PluginList::Singleton()->UnregisterInternalPlugin(path);
 }
 
 void PluginServiceImpl::GetInternalPlugins(
-    std::vector<webkit::WebPluginInfo>* plugins) {
+    std::vector<WebPluginInfo>* plugins) {
   PluginList::Singleton()->GetInternalPlugins(plugins);
 }
 
 bool PluginServiceImpl::NPAPIPluginsSupported() {
 #if defined(OS_WIN) || defined(OS_MACOSX) || (defined(OS_LINUX) && !defined(USE_AURA))
   return true;
 #else
   return false;
 #endif
 }
@@ skipping 38 matching lines @@
           window, kPluginVersionAtomProperty, plugin_version);
   return true;
 }
 
 bool PluginServiceImpl::IsPluginWindow(HWND window) {
   return ui::GetClassName(window) == base::string16(kNativeWindowClassName);
 }
 #endif
 
 }  // namespace content