Move the NPAPI files from webkit/glue/plugins to webkit/plugins/npapi and put...

chrome/browser/plugin_updater.cc

 // Copyright (c) 2010 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 "chrome/browser/plugin_updater.h"
 
 #include <set>
 #include <string>
 
 #include "base/command_line.h"
 #include "base/message_loop.h"
 #include "base/path_service.h"
 #include "base/scoped_ptr.h"
 #include "base/utf_string_conversions.h"
 #include "base/values.h"
 #include "base/version.h"
 #include "chrome/browser/browser_thread.h"
 #include "chrome/browser/prefs/pref_service.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/common/chrome_paths.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/notification_service.h"
 #include "chrome/common/pepper_plugin_registry.h"
 #include "chrome/common/pref_names.h"
-#include "webkit/glue/plugins/webplugininfo.h"
+#include "webkit/plugins/npapi/plugin_list.h"
+#include "webkit/plugins/npapi/webplugininfo.h"
 
 // How long to wait to save the plugin enabled information, which might need to
 // go to disk.
 #define kPluginUpdateDelayMs (60 * 1000)
 
 PluginUpdater::PluginUpdater()
     : enable_internal_pdf_(true),
       notify_pending_(false) {
 }
 
 DictionaryValue* PluginUpdater::CreatePluginFileSummary(
-    const WebPluginInfo& plugin) {
+    const webkit::npapi::WebPluginInfo& plugin) {
   DictionaryValue* data = new DictionaryValue();
   data->SetString("path", plugin.path.value());
   data->SetString("name", plugin.name);
   data->SetString("version", plugin.version);
   data->SetBoolean("enabled", plugin.enabled);
   return data;
 }
 
 // static
 ListValue* PluginUpdater::GetPluginGroupsData() {
-  std::vector<PluginGroup> plugin_groups;
-  NPAPI::PluginList::Singleton()->GetPluginGroups(true, &plugin_groups);
+  std::vector<webkit::npapi::PluginGroup> plugin_groups;
+  webkit::npapi::PluginList::Singleton()->GetPluginGroups(true, &plugin_groups);
 
   // Construct DictionaryValues to return to the UI
   ListValue* plugin_groups_data = new ListValue();
   for (size_t i = 0; i < plugin_groups.size(); ++i) {
     plugin_groups_data->Append(plugin_groups[i].GetDataForUI());
   }
   return plugin_groups_data;
 }
 
 void PluginUpdater::EnablePluginGroup(bool enable, const string16& group_name) {
-  if (PluginGroup::IsPluginNameDisabledByPolicy(group_name))
+  if (webkit::npapi::PluginGroup::IsPluginNameDisabledByPolicy(group_name))
     enable = false;
-  NPAPI::PluginList::Singleton()->EnableGroup(enable, group_name);
+  webkit::npapi::PluginList::Singleton()->EnableGroup(enable, group_name);
   NotifyPluginStatusChanged();
 }
 
 void PluginUpdater::EnablePluginFile(bool enable,
                                      const FilePath::StringType& path) {
   FilePath file_path(path);
-  if (enable && !PluginGroup::IsPluginPathDisabledByPolicy(file_path))
-    NPAPI::PluginList::Singleton()->EnablePlugin(file_path);
+  if (enable &&
+      !webkit::npapi::PluginGroup::IsPluginPathDisabledByPolicy(file_path))
+    webkit::npapi::PluginList::Singleton()->EnablePlugin(file_path);
   else
-    NPAPI::PluginList::Singleton()->DisablePlugin(file_path);
+    webkit::npapi::PluginList::Singleton()->DisablePlugin(file_path);
 
   NotifyPluginStatusChanged();
 }
 
 void PluginUpdater::Observe(NotificationType type,
                             const NotificationSource& source,
                             const NotificationDetails& details) {
   DCHECK_EQ(NotificationType::PREF_CHANGED, type.value);
   const std::string* pref_name = Details<std::string>(details).ptr();
   if (!pref_name) {
@@ skipping 15 matching lines @@
   if (plugin_names) {
     ListValue::const_iterator end(plugin_names->end());
     for (ListValue::const_iterator current(plugin_names->begin());
          current != end; ++current) {
       string16 plugin_name;
       if ((*current)->GetAsString(&plugin_name)) {
         policy_disabled_plugin_patterns.insert(plugin_name);
       }
     }
   }
-  PluginGroup::SetPolicyDisabledPluginPatterns(policy_disabled_plugin_patterns);
+  webkit::npapi::PluginGroup::SetPolicyDisabledPluginPatterns(
+      policy_disabled_plugin_patterns);
 
   NotifyPluginStatusChanged();
 }
 
 void PluginUpdater::DisablePluginGroupsFromPrefs(Profile* profile) {
   bool update_internal_dir = false;
   FilePath last_internal_dir =
   profile->GetPrefs()->GetFilePath(prefs::kPluginsLastInternalDirectory);
   FilePath cur_internal_dir;
   if (PathService::Get(chrome::DIR_INTERNAL_PLUGINS, &cur_internal_dir) &&
@@ skipping 64 matching lines @@
           if (!enabled) {
             if (force_enable_internal_pdf) {
               enabled = true;
               plugin->SetBoolean("enabled", true);
             } else if (force_internal_pdf_for_this_run) {
               enabled = true;
             }
           }
         }
         if (!enabled)
-          NPAPI::PluginList::Singleton()->DisablePlugin(plugin_path);
+          webkit::npapi::PluginList::Singleton()->DisablePlugin(plugin_path);
       } else if (!enabled && plugin->GetString("name", &group_name)) {
         // Don't disable this group if it's for the pdf plugin and we just
         // forced it on.
         if (force_enable_internal_pdf && pdf_group_name == group_name)
           continue;
 
         // Otherwise this is a list of groups.
         EnablePluginGroup(false, group_name);
       }
     }
   }
 
   // Build the set of policy-disabled plugin patterns once and cache it.
   // Don't do this in the constructor, there's no profile available there.
   const ListValue* plugin_blacklist =
       profile->GetPrefs()->GetList(prefs::kPluginsPluginsBlacklist);
   DisablePluginsFromPolicy(plugin_blacklist);
 
   if ((!enable_internal_pdf_ && !found_internal_pdf) &&
       !force_internal_pdf_for_this_run) {
     // The internal PDF plugin is disabled by default, and the user hasn't
     // overridden the default.
-    NPAPI::PluginList::Singleton()->DisablePlugin(pdf_path);
+    webkit::npapi::PluginList::Singleton()->DisablePlugin(pdf_path);
     EnablePluginGroup(false, pdf_group_name);
   }
 
   if (force_enable_internal_pdf) {
     // See http://crbug.com/50105 for background.
-    EnablePluginGroup(false, ASCIIToUTF16(PluginGroup::kAdobeReaderGroupName));
+    EnablePluginGroup(false, ASCIIToUTF16(
+        webkit::npapi::PluginGroup::kAdobeReaderGroupName));
 
     // We want to save this, but doing so requires loading the list of plugins,
     // so do it after a minute as to not impact startup performance.  Note that
     // plugins are loaded after 30s by the metrics service.
     UpdatePreferences(profile, kPluginUpdateDelayMs);
   }
 }
 
 void PluginUpdater::UpdatePreferences(Profile* profile, int delay_ms) {
   BrowserThread::PostDelayedTask(
     BrowserThread::FILE,
     FROM_HERE,
     NewRunnableFunction(
         &PluginUpdater::GetPreferencesDataOnFileThread, profile), delay_ms);
 }
 
 void PluginUpdater::GetPreferencesDataOnFileThread(void* profile) {
-  std::vector<WebPluginInfo> plugins;
-  NPAPI::PluginList::Singleton()->GetPlugins(false, &plugins);
+  std::vector<webkit::npapi::WebPluginInfo> plugins;
+  webkit::npapi::PluginList::Singleton()->GetPlugins(false, &plugins);
 
-  std::vector<PluginGroup> groups;
-  NPAPI::PluginList::Singleton()->GetPluginGroups(false, &groups);
+  std::vector<webkit::npapi::PluginGroup> groups;
+  webkit::npapi::PluginList::Singleton()->GetPluginGroups(false, &groups);
 
   BrowserThread::PostTask(
     BrowserThread::UI,
     FROM_HERE,
     NewRunnableFunction(
         &PluginUpdater::OnUpdatePreferences,
         static_cast<Profile*>(profile), plugins, groups));
 }
 
 void PluginUpdater::OnUpdatePreferences(
     Profile* profile,
-    const std::vector<WebPluginInfo>& plugins,
-    const std::vector<PluginGroup>& groups) {
+    const std::vector<webkit::npapi::WebPluginInfo>& plugins,
+    const std::vector<webkit::npapi::PluginGroup>& groups) {
   ListValue* plugins_list = profile->GetPrefs()->GetMutableList(
       prefs::kPluginsPluginsList);
   plugins_list->Clear();
 
   FilePath internal_dir;
   if (PathService::Get(chrome::DIR_INTERNAL_PLUGINS, &internal_dir))
     profile->GetPrefs()->SetFilePath(prefs::kPluginsLastInternalDirectory,
                                      internal_dir);
 
   // Add the plugin files.
-  for (std::vector<WebPluginInfo>::const_iterator it = plugins.begin();
+  for (std::vector<webkit::npapi::WebPluginInfo>::const_iterator it =
+           plugins.begin();
        it != plugins.end();
        ++it) {
     plugins_list->Append(CreatePluginFileSummary(*it));
   }
 
   // Add the groups as well.
   for (size_t i = 0; i < groups.size(); ++i) {
     // Don't save preferences for vulnerable pugins.
     if (!CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kDisableOutdatedPlugins) ||
@@ skipping 17 matching lines @@
   NotificationService::current()->Notify(
       NotificationType::PLUGIN_ENABLE_STATUS_CHANGED,
       Source<PluginUpdater>(GetInstance()),
       NotificationService::NoDetails());
 }
 
 /*static*/
 PluginUpdater* PluginUpdater::GetInstance() {
   return Singleton<PluginUpdater>::get();
 }