Remove webkit/plugins/npapi.

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 "webkit/plugins/npapi/plugin_utils.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
 
 #if defined(OS_POSIX) && !defined(OS_OPENBSD) && !defined(OS_ANDROID)
 using ::base::FilePathWatcher;
 #endif
 
@@ skipping 18 matching lines @@
   return true;
 #else
   // If on POSIX, we don't want to load the list of NPAPI plugins in-process as
   // that causes instability.
 
   // Can't load the plugins on the utility thread when in single process mode
   // since that requires GTK which can only be used on the main thread.
   if (RenderProcessHost::run_renderer_in_process())
     return true;
 
-  return !webkit::npapi::NPAPIPluginsSupported();
+  return !PluginService::GetInstance()->NPAPIPluginsSupported();
 #endif
 }
 
 // Callback set on the PluginList to assert that plugin loading happens on the
 // correct thread.
 void WillLoadPluginsCallback(
     base::SequencedWorkerPool::SequenceToken token) {
   if (LoadPluginListInProcess()) {
     CHECK(BrowserThread::GetBlockingPool()->IsRunningSequenceOnCurrentThread(
         token));
@@ skipping 418 matching lines @@
 }
 
 bool PluginServiceImpl::GetPluginInfoArray(
     const GURL& url,
     const std::string& mime_type,
     bool allow_wildcard,
     std::vector<webkit::WebPluginInfo>* plugins,
     std::vector<std::string>* actual_mime_types) {
   bool use_stale = false;
   PluginList::Singleton()->GetPluginInfoArray(
-      url, mime_type, allow_wildcard, &use_stale, plugins, actual_mime_types);
+      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,
@@ skipping 93 matching lines @@
 #endif
 }
 
 void PluginServiceImpl::GetPluginsInternal(
      base::MessageLoopProxy* target_loop,
      const PluginService::GetPluginsCallback& callback) {
   DCHECK(BrowserThread::GetBlockingPool()->IsRunningSequenceOnCurrentThread(
       plugin_list_token_));
 
   std::vector<webkit::WebPluginInfo> plugins;
-  PluginList::Singleton()->GetPlugins(&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_) {
     hkcu_key_.StartWatching();
@@ skipping 106 matching lines @@
   }
   base::TimeDelta delta = base::Time::Now() - i->second[0];
   return delta.InSeconds() <= kCrashesInterval;
 }
 
 void PluginServiceImpl::RefreshPlugins() {
   PluginList::Singleton()->RefreshPlugins();
 }
 
 void PluginServiceImpl::AddExtraPluginPath(const base::FilePath& path) {
+ if (!NPAPIPluginsSupported()) {
+    // TODO(jam): remove and just have CHECK once we're sure this doesn't get
+    // triggered.
+    DLOG(INFO) << "NPAPI plugins not supported";
+    return;
+  }
   PluginList::Singleton()->AddExtraPluginPath(path);
 }
 
 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,
     bool add_at_beginning) {
+  if (!NPAPIPluginsSupported() &&
+      info.type == webkit::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) {
   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
+}
+
 void PluginServiceImpl::DisablePluginsDiscoveryForTesting() {
   PluginList::Singleton()->DisablePluginsDiscovery();
 }
 
 #if defined(OS_MACOSX)
 void PluginServiceImpl::AppActivated() {
   BrowserThread::PostTask(BrowserThread::IO, FROM_HERE,
                           base::Bind(&NotifyPluginsOfActivation));
 }
+#elif defined(OS_WIN)
+
+bool GetPluginPropertyFromWindow(
+    HWND window, const wchar_t* plugin_atom_property,
+    base::string16* plugin_property) {
+  ATOM plugin_atom = reinterpret_cast<ATOM>(
+      GetPropW(window, plugin_atom_property));
+  if (plugin_atom != 0) {
+    WCHAR plugin_property_local[MAX_PATH] = {0};
+    GlobalGetAtomNameW(plugin_atom,
+                       plugin_property_local,
+                       ARRAYSIZE(plugin_property_local));
+    *plugin_property = plugin_property_local;
+    return true;
+  }
+  return false;
+}
+
+bool PluginServiceImpl::GetPluginInfoFromWindow(
+    HWND window,
+    base::string16* plugin_name,
+    base::string16* plugin_version) {
+  if (!IsPluginWindow(window))
+    return false;
+
+  GetPluginPropertyFromWindow(
+          window, kPluginNameAtomProperty, plugin_name);
+  GetPluginPropertyFromWindow(
+          window, kPluginVersionAtomProperty, plugin_version);
+  return true;
+}
+
+bool PluginServiceImpl::IsPluginWindow(HWND window) {
+  return ui::GetClassName(window) == base::string16(kNativeWindowClassName);
+}
 #endif
 
 }  // namespace content