Move webplugininfo.h to content/public.

content/common/plugin_list.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/common/plugin_list.h"
 
 #include <algorithm>
 
 #include "base/command_line.h"
 #include "base/lazy_instance.h"
 #include "base/logging.h"
 #include "base/strings/string_split.h"
 #include "base/strings/string_util.h"
 #include "base/strings/sys_string_conversions.h"
 #include "base/strings/utf_string_conversions.h"
 #include "net/base/mime_util.h"
 #include "url/gurl.h"
 #include "webkit/plugins/plugin_switches.h"
 
 #if defined(OS_WIN)
 #include "content/common/plugin_constants_win.h"
 #endif
 
-using webkit::WebPluginInfo;
-using webkit::WebPluginMimeType;
-
 namespace content {
 
 namespace {
 
 const char kApplicationOctetStream[] = "application/octet-stream";
 
 base::LazyInstance<PluginList> g_singleton = LAZY_INSTANCE_INITIALIZER;
 
 bool AllowMimeTypeMismatch(const std::string& orig_mime_type,
                            const std::string& actual_mime_type) {
@@ skipping 56 matching lines @@
 }
 
 void PluginList::AddExtraPluginDir(const base::FilePath& plugin_dir) {
   // Chrome OS only loads plugins from /opt/google/chrome/plugins.
 #if !defined(OS_CHROMEOS)
   base::AutoLock lock(lock_);
   extra_plugin_dirs_.push_back(plugin_dir);
 #endif
 }
 
-void PluginList::RegisterInternalPlugin(const webkit::WebPluginInfo& info,
+void PluginList::RegisterInternalPlugin(const WebPluginInfo& info,
                                         bool add_at_beginning) {
   base::AutoLock lock(lock_);
 
   internal_plugins_.push_back(info);
   if (add_at_beginning) {
     // Newer registrations go earlier in the list so they can override the MIME
     // types of older registrations.
     extra_plugin_paths_.insert(extra_plugin_paths_.begin(), info.path);
   } else {
     extra_plugin_paths_.push_back(info.path);
   }
 }
 
 void PluginList::UnregisterInternalPlugin(const base::FilePath& path) {
   base::AutoLock lock(lock_);
   for (size_t i = 0; i < internal_plugins_.size(); i++) {
     if (internal_plugins_[i].path == path) {
       internal_plugins_.erase(internal_plugins_.begin() + i);
       return;
     }
   }
   NOTREACHED();
 }
 
 void PluginList::GetInternalPlugins(
-    std::vector<webkit::WebPluginInfo>* internal_plugins) {
+    std::vector<WebPluginInfo>* internal_plugins) {
   base::AutoLock lock(lock_);
 
-  for (std::vector<webkit::WebPluginInfo>::iterator it =
-          internal_plugins_.begin();
+  for (std::vector<WebPluginInfo>::iterator it = internal_plugins_.begin();
        it != internal_plugins_.end();
        ++it) {
     internal_plugins->push_back(*it);
   }
 }
 
 bool PluginList::ReadPluginInfo(const base::FilePath& filename,
-                                webkit::WebPluginInfo* info) {
+                                WebPluginInfo* info) {
   {
     base::AutoLock lock(lock_);
     for (size_t i = 0; i < internal_plugins_.size(); ++i) {
       if (filename == internal_plugins_[i].path) {
         *info = internal_plugins_[i];
         return true;
       }
     }
   }
 
   return PluginList::ReadWebPluginInfo(filename, info);
 }
 
 // static
 bool PluginList::ParseMimeTypes(
     const std::string& mime_types_str,
     const std::string& file_extensions_str,
     const base::string16& mime_type_descriptions_str,
-    std::vector<webkit::WebPluginMimeType>* parsed_mime_types) {
+    std::vector<WebPluginMimeType>* parsed_mime_types) {
   std::vector<std::string> mime_types, file_extensions;
   std::vector<base::string16> descriptions;
   base::SplitString(mime_types_str, '|', &mime_types);
   base::SplitString(file_extensions_str, '|', &file_extensions);
   base::SplitString(mime_type_descriptions_str, '|', &descriptions);
 
   parsed_mime_types->clear();
 
   if (mime_types.empty())
     return false;
@@ skipping 32 matching lines @@
 
 void PluginList::LoadPlugins(bool include_npapi) {
   {
     base::AutoLock lock(lock_);
     if (loading_state_ == LOADING_STATE_UP_TO_DATE)
       return;
 
     loading_state_ = LOADING_STATE_REFRESHING;
   }
 
-  std::vector<webkit::WebPluginInfo> new_plugins;
+  std::vector<WebPluginInfo> new_plugins;
   base::Closure will_load_callback;
   {
     base::AutoLock lock(lock_);
     will_load_callback = will_load_plugins_callback_;
   }
   if (!will_load_callback.is_null())
     will_load_callback.Run();
 
   std::vector<base::FilePath> plugin_paths;
   GetPluginPathsToLoad(&plugin_paths, include_npapi);
 
   for (std::vector<base::FilePath>::const_iterator it = plugin_paths.begin();
        it != plugin_paths.end();
        ++it) {
     WebPluginInfo plugin_info;
     LoadPluginIntoPluginList(*it, &new_plugins, &plugin_info);
   }
 
   base::AutoLock lock(lock_);
   plugins_list_.swap(new_plugins);
 
   // If we haven't been invalidated in the mean time, mark the plug-in list as
   // up-to-date.
   if (loading_state_ != LOADING_STATE_NEEDS_REFRESH)
     loading_state_ = LOADING_STATE_UP_TO_DATE;
 }
 
 bool PluginList::LoadPluginIntoPluginList(
     const base::FilePath& path,
-    std::vector<webkit::WebPluginInfo>* plugins,
+    std::vector<WebPluginInfo>* plugins,
     WebPluginInfo* plugin_info) {
   LOG_IF(ERROR, PluginList::DebugPluginLoading())
       << "Loading plugin " << path.value();
   if (!ReadPluginInfo(path, plugin_info))
     return false;
 
   if (!ShouldLoadPluginUsingPluginList(*plugin_info, plugins))
     return false;
 
 #if defined(OS_WIN) && !defined(NDEBUG)
@@ skipping 44 matching lines @@
     GetPluginDirectories(&directories_to_scan);
     for (size_t i = 0; i < directories_to_scan.size(); ++i)
       GetPluginsInDir(directories_to_scan[i], plugin_paths);
 
 #if defined(OS_WIN)
     GetPluginPathsFromRegistry(plugin_paths);
 #endif
   }
 }
 
-void PluginList::SetPlugins(const std::vector<webkit::WebPluginInfo>& plugins) {
+void PluginList::SetPlugins(const std::vector<WebPluginInfo>& plugins) {
   base::AutoLock lock(lock_);
 
   DCHECK_NE(LOADING_STATE_REFRESHING, loading_state_);
   loading_state_ = LOADING_STATE_UP_TO_DATE;
 
   plugins_list_.clear();
   plugins_list_.insert(plugins_list_.end(), plugins.begin(), plugins.end());
 }
 
 void PluginList::set_will_load_plugins_callback(const base::Closure& callback) {
   base::AutoLock lock(lock_);
   will_load_plugins_callback_ = callback;
 }
 
 void PluginList::GetPlugins(std::vector<WebPluginInfo>* plugins,
                             bool include_npapi) {
   LoadPlugins(include_npapi);
   base::AutoLock lock(lock_);
   plugins->insert(plugins->end(), plugins_list_.begin(), plugins_list_.end());
 }
 
-bool PluginList::GetPluginsNoRefresh(
-    std::vector<webkit::WebPluginInfo>* plugins) {
+bool PluginList::GetPluginsNoRefresh(std::vector<WebPluginInfo>* plugins) {
   base::AutoLock lock(lock_);
   plugins->insert(plugins->end(), plugins_list_.begin(), plugins_list_.end());
 
   return loading_state_ == LOADING_STATE_UP_TO_DATE;
 }
 
 void PluginList::GetPluginInfoArray(
     const GURL& url,
     const std::string& mime_type,
     bool allow_wildcard,
     bool* use_stale,
     bool include_npapi,
-    std::vector<webkit::WebPluginInfo>* info,
+    std::vector<WebPluginInfo>* info,
     std::vector<std::string>* actual_mime_types) {
   DCHECK(mime_type == StringToLowerASCII(mime_type));
   DCHECK(info);
 
   if (!use_stale)
     LoadPlugins(include_npapi);
   base::AutoLock lock(lock_);
   if (use_stale)
     *use_stale = (loading_state_ != LOADING_STATE_UP_TO_DATE);
   info->clear();
@@ skipping 27 matching lines @@
             AllowMimeTypeMismatch(mime_type, actual_mime_type)) {
           info->push_back(plugins_list_[i]);
           if (actual_mime_types)
             actual_mime_types->push_back(actual_mime_type);
         }
       }
     }
   }
 }
 
-bool PluginList::SupportsType(const webkit::WebPluginInfo& plugin,
+bool PluginList::SupportsType(const WebPluginInfo& plugin,
                               const std::string& mime_type,
                               bool allow_wildcard) {
   // Webkit will ask for a plugin to handle empty mime types.
   if (mime_type.empty())
     return false;
 
   for (size_t i = 0; i < plugin.mime_types.size(); ++i) {
-    const webkit::WebPluginMimeType& mime_info = plugin.mime_types[i];
+    const WebPluginMimeType& mime_info = plugin.mime_types[i];
     if (net::MatchesMimeType(mime_info.mime_type, mime_type)) {
       if (!allow_wildcard && mime_info.mime_type == "*")
         continue;
       return true;
     }
   }
   return false;
 }
 
-bool PluginList::SupportsExtension(const webkit::WebPluginInfo& plugin,
+bool PluginList::SupportsExtension(const WebPluginInfo& plugin,
                                    const std::string& extension,
                                    std::string* actual_mime_type) {
   for (size_t i = 0; i < plugin.mime_types.size(); ++i) {
-    const webkit::WebPluginMimeType& mime_type = plugin.mime_types[i];
+    const WebPluginMimeType& mime_type = plugin.mime_types[i];
     for (size_t j = 0; j < mime_type.file_extensions.size(); ++j) {
       if (mime_type.file_extensions[j] == extension) {
         if (actual_mime_type)
           *actual_mime_type = mime_type.mime_type;
         return true;
       }
     }
   }
   return false;
 }
 
 PluginList::~PluginList() {
 }
 
 
 }  // namespace content