Move NPAPI implementation out of webkit/plugins/npapi and into content.

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 "webkit/plugins/npapi/plugin_list.h"
+#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/npapi/plugin_utils.h"
 #include "webkit/plugins/plugin_switches.h"
 
 #if defined(OS_WIN)
-#include "webkit/plugins/npapi/plugin_constants_win.h"
+#include "content/common/plugin_constants_win.h"
 #endif
 
+using webkit::WebPluginInfo;
+using webkit::WebPluginMimeType;
+
+namespace content {
+
 namespace {
 
-using webkit::npapi::PluginList;
-
 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) {
   if (orig_mime_type == actual_mime_type) {
     NOTREACHED();
     return true;
   }
 
   // We do not permit URL-sniff based plug-in MIME type overrides aside from
   // the case where the "type" was initially missing or generic
   // (application/octet-stream).
   // We collected stats to determine this approach isn't a major compat issue,
   // and we defend against content confusion attacks in various cases, such
   // as when the user doesn't have the Flash plug-in enabled.
   bool allow = orig_mime_type.empty() ||
                orig_mime_type == kApplicationOctetStream;
   LOG_IF(INFO, !allow) << "Ignoring plugin with unexpected MIME type "
                        << actual_mime_type << " (expected " << orig_mime_type
                        << ")";
   return allow;
 }
 
 }  // namespace
 
-namespace webkit {
-namespace npapi {
-
 // static
 PluginList* PluginList::Singleton() {
   return g_singleton.Pointer();
 }
 
 // static
 bool PluginList::DebugPluginLoading() {
   return CommandLine::ForCurrentProcess()->HasSwitch(
       switches::kDebugPluginLoading);
 }
 
 void PluginList::DisablePluginsDiscovery() {
   plugins_discovery_disabled_ = true;
 }
 
 void PluginList::RefreshPlugins() {
   base::AutoLock lock(lock_);
   loading_state_ = LOADING_STATE_NEEDS_REFRESH;
 }
 
 void PluginList::AddExtraPluginPath(const base::FilePath& plugin_path) {
-  if (!NPAPIPluginsSupported()) {
+  if (!webkit::npapi::NPAPIPluginsSupported()) {
     // TODO(jam): remove and just have CHECK once we're sure this doesn't get
     // triggered.
     DLOG(INFO) << "NPAPI plugins not supported";
     return;
   }
 
   // Chrome OS only loads plugins from /opt/google/chrome/plugins.
 #if !defined(OS_CHROMEOS)
   base::AutoLock lock(lock_);
   extra_plugin_paths_.push_back(plugin_path);
@@ skipping 12 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,
                                         bool add_at_beginning) {
-  if (!NPAPIPluginsSupported() &&
+  if (!webkit::npapi::NPAPIPluginsSupported() &&
       info.type == WebPluginInfo::PLUGIN_TYPE_NPAPI) {
     DLOG(INFO) << "Don't register NPAPI plugins when they're not supported";
     return;
   }
 
   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
@@ skipping 176 matching lines @@
 
   for (size_t i = 0; i < extra_plugin_paths.size(); ++i) {
     const base::FilePath& path = extra_plugin_paths[i];
     if (std::find(plugin_paths->begin(), plugin_paths->end(), path) !=
         plugin_paths->end()) {
       continue;
     }
     plugin_paths->push_back(path);
   }
 
-  if (NPAPIPluginsSupported()) {
+  if (webkit::npapi::NPAPIPluginsSupported()) {
     // A bit confusingly, this function is used to load Pepper plugins as well.
     // Those are all internal plugins so we have to use extra_plugin_paths.
     for (size_t i = 0; i < extra_plugin_dirs.size(); ++i)
       GetPluginsInDir(extra_plugin_dirs[i], plugin_paths);
 
     std::vector<base::FilePath> directories_to_scan;
     GetPluginDirectories(&directories_to_scan);
     for (size_t i = 0; i < directories_to_scan.size(); ++i)
       GetPluginsInDir(directories_to_scan[i], plugin_paths);
 
@@ skipping 116 matching lines @@
       }
     }
   }
   return false;
 }
 
 PluginList::~PluginList() {
 }
 
 
-}  // namespace npapi
-}  // namespace webkit
+}  // namespace content