1st CL in a series to remove PluginGroup. Updates PluginList.

webkit/plugins/npapi/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 <algorithm>
 
 #include "base/command_line.h"
 #include "base/lazy_instance.h"
@@ skipping 35 matching lines @@
                        << actual_mime_type << " (expected " << orig_mime_type
                        << ")";
   return allow;
 }
 
 }
 
 namespace webkit {
 namespace npapi {
 
+// TODO(ibraaaa): DELETE all hardcoded definitions.
 // Note: If you change the plug-in definitions here, also update
 // chrome/browser/resources/plugins_*.json correspondingly!
 // In particular, the identifier needs to be kept in sync.
 
 // Try and share the group definition for plug-ins that are
 // very consistent across OS'es.
 #define kFlashDefinition { \
     "adobe-flash-player", "Flash", "Shockwave Flash" }
 
 #define kShockwaveDefinition { \
@@ skipping 217 matching lines @@
   return true;
 }
 
 PluginList::PluginList()
     : loading_state_(LOADING_STATE_NEEDS_REFRESH) {
   PlatformInit();
   AddHardcodedPluginGroups(kGroupDefinitions,
                            ARRAYSIZE_UNSAFE(kGroupDefinitions));
 }
 
+// TODO(ibraaaa): DELETE and add a different one
 PluginList::PluginList(const PluginGroupDefinition* definitions,
                        size_t num_definitions)
     :
 #if defined(OS_WIN)
       dont_load_new_wmp_(false),
 #endif
       loading_state_(LOADING_STATE_NEEDS_REFRESH) {
   // Don't do platform-dependent initialization in unit tests.
   AddHardcodedPluginGroups(definitions, num_definitions);
 }
 
+// TODO(ibraaaa): DELETE
 PluginGroup* PluginList::CreatePluginGroup(
       const webkit::WebPluginInfo& web_plugin_info) const {
   for (size_t i = 0; i < hardcoded_plugin_groups_.size(); ++i) {
     const PluginGroup* group = hardcoded_plugin_groups_[i];
     if (group->Match(web_plugin_info))
       return new PluginGroup(*group);
   }
   return PluginGroup::FromWebPluginInfo(web_plugin_info);
 }
 
+// TODO(ibraaaa): DELETE
 void PluginList::LoadPluginsInternal(ScopedVector<PluginGroup>* plugin_groups) {
   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<FilePath> plugin_paths;
   GetPluginPathsToLoad(&plugin_paths);
 
   for (std::vector<FilePath>::const_iterator it = plugin_paths.begin();
        it != plugin_paths.end();
        ++it) {
     WebPluginInfo plugin_info;
     LoadPlugin(*it, plugin_groups, &plugin_info);
   }
 }
 
+void PluginList::LoadPluginsIntoPluginListInternal(
+    std::vector<webkit::WebPluginInfo>* 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<FilePath> plugin_paths;
+  GetPluginPathsToLoad(&plugin_paths);
+
+  for (std::vector<FilePath>::const_iterator it = plugin_paths.begin();
+       it != plugin_paths.end();
+       ++it) {
+    WebPluginInfo plugin_info;
+    LoadPluginIntoPluginList(*it, plugins, &plugin_info);
+  }
+}
+
 void PluginList::LoadPlugins() {
   {
     base::AutoLock lock(lock_);
     if (loading_state_ == LOADING_STATE_UP_TO_DATE)
       return;
 
     loading_state_ = LOADING_STATE_REFRESHING;
   }
 
-  ScopedVector<PluginGroup> new_plugin_groups;
+  ScopedVector<PluginGroup> new_plugin_groups; // TODO(ibraaaa): DELETE

[Bernhard Bauer, 2012/08/20 17:22:42]

Nit: two spaces before comment. Same below.

[ibraaaa, 2012/08/20 18:05:29]

Done.

   // Do the actual loading of the plugins.
-  LoadPluginsInternal(&new_plugin_groups);
+  LoadPluginsInternal(&new_plugin_groups); // TODO(ibraaaa): DELETE
+
+  std::vector<webkit::WebPluginInfo> new_plugins;
+  // Do the actual loading of the plugins.
+  LoadPluginsIntoPluginListInternal(&new_plugins);
 
   base::AutoLock lock(lock_);
-  plugin_groups_.swap(new_plugin_groups);
+  plugin_groups_.swap(new_plugin_groups); // TODO(ibraaaa): DELETE
+  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;
 }
 
+// TODO(ibraaaa): DELETE
 bool PluginList::LoadPlugin(const FilePath& path,
                             ScopedVector<PluginGroup>* plugin_groups,
                             WebPluginInfo* plugin_info) {
   LOG_IF(ERROR, PluginList::DebugPluginLoading())
       << "Loading plugin " << path.value();
   const PluginEntryPoints* entry_points;
 
   if (!ReadPluginInfo(path, plugin_info, &entry_points))
     return false;
 
@@ skipping 10 matching lines @@
       // to handle mimeTypes on its own.
       const std::string &mime_type = plugin_info->mime_types[i].mime_type;
       if (mime_type == "*")
         return false;
     }
   }
   AddToPluginGroups(*plugin_info, plugin_groups);
   return true;
 }
 
+bool PluginList::LoadPluginIntoPluginList(
+    const FilePath& path,
+    std::vector<webkit::WebPluginInfo>* plugins,
+    WebPluginInfo* plugin_info) {
+  LOG_IF(ERROR, PluginList::DebugPluginLoading())
+      << "Loading plugin " << path.value();
+  const PluginEntryPoints* entry_points;
+
+  if (!ReadPluginInfo(path, plugin_info, &entry_points))
+    return false;
+
+  if (!ShouldLoadPluginUsingPluginList(*plugin_info, plugins))
+    return false;
+
+#if defined(OS_WIN) && !defined(NDEBUG)
+  if (path.BaseName().value() != L"npspy.dll")  // Make an exception for NPSPY
+#endif
+  {
+    for (size_t i = 0; i < plugin_info->mime_types.size(); ++i) {
+      // TODO: don't load global handlers for now.
+      // WebKit hands to the Plugin before it tries
+      // to handle mimeTypes on its own.
+      const std::string &mime_type = plugin_info->mime_types[i].mime_type;
+      if (mime_type == "*")
+        return false;
+    }
+  }
+  plugins->push_back(*plugin_info);
+  return true;
+}
+
 void PluginList::GetPluginPathsToLoad(std::vector<FilePath>* plugin_paths) {
   // Don't want to hold the lock while loading new plugins, so we don't block
   // other methods if they're called on other threads.
   std::vector<FilePath> extra_plugin_paths;
   std::vector<FilePath> extra_plugin_dirs;
   {
     base::AutoLock lock(lock_);
     extra_plugin_paths = extra_plugin_paths_;
     extra_plugin_dirs = extra_plugin_dirs_;
   }
@@ skipping 14 matching lines @@
     GetPluginsInDir(extra_plugin_dirs[i], plugin_paths);
 
   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
 }
 
+// TODO(ibraaaa): DELETE
 const std::vector<PluginGroup*>& PluginList::GetHardcodedPluginGroups() const {
   return hardcoded_plugin_groups_.get();
 }
 
 void PluginList::SetPlugins(const std::vector<webkit::WebPluginInfo>& plugins) {
   base::AutoLock lock(lock_);
 
   DCHECK_NE(LOADING_STATE_REFRESHING, loading_state_);
   loading_state_ = LOADING_STATE_UP_TO_DATE;
 
+  // TODO(ibraaaa): DELETE
   plugin_groups_.clear();
   for (std::vector<webkit::WebPluginInfo>::const_iterator it = plugins.begin();
        it != plugins.end();
        ++it) {
     AddToPluginGroups(*it, &plugin_groups_);
-  }
+  } // END OF DELETE
+
+  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) {
   LoadPlugins();
   base::AutoLock lock(lock_);
-  for (size_t i = 0; i < plugin_groups_.size(); ++i) {
-    const std::vector<webkit::WebPluginInfo>& gr_plugins =
-        plugin_groups_[i]->web_plugin_infos();
-    plugins->insert(plugins->end(), gr_plugins.begin(), gr_plugins.end());
-  }
+  plugins->insert(plugins->end(), plugins_list_.begin(), plugins_list_.end());
 }
 
 bool PluginList::GetPluginsNoRefresh(
     std::vector<webkit::WebPluginInfo>* plugins) {
   base::AutoLock lock(lock_);
-  for (size_t i = 0; i < plugin_groups_.size(); ++i) {
-    const std::vector<webkit::WebPluginInfo>& gr_plugins =
-        plugin_groups_[i]->web_plugin_infos();
-    plugins->insert(plugins->end(), gr_plugins.begin(), gr_plugins.end());
-  }
+  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,
     std::vector<webkit::WebPluginInfo>* info,
     std::vector<std::string>* actual_mime_types) {
   DCHECK(mime_type == StringToLowerASCII(mime_type));
   DCHECK(info);
 
   if (!use_stale)
     LoadPlugins();
   base::AutoLock lock(lock_);
   if (use_stale)
     *use_stale = (loading_state_ != LOADING_STATE_UP_TO_DATE);
   info->clear();
   if (actual_mime_types)
     actual_mime_types->clear();
 
   std::set<FilePath> visited_plugins;
 
   // Add in plugins by mime type.
-  for (size_t i = 0; i < plugin_groups_.size(); ++i) {
-    const std::vector<webkit::WebPluginInfo>& plugins =
-        plugin_groups_[i]->web_plugin_infos();
-    for (size_t i = 0; i < plugins.size(); ++i) {
-      if (SupportsType(plugins[i], mime_type, allow_wildcard)) {
-        FilePath path = plugins[i].path;
-        if (visited_plugins.insert(path).second) {
-          info->push_back(plugins[i]);
-          if (actual_mime_types)
-            actual_mime_types->push_back(mime_type);
-        }
+  for (size_t i = 0; i < plugins_list_.size(); ++i) {
+    if (SupportsType(plugins_list_[i], mime_type, allow_wildcard)) {
+      FilePath path = plugins_list_[i].path;
+      if (visited_plugins.insert(path).second) {
+        info->push_back(plugins_list_[i]);
+        if (actual_mime_types)
+          actual_mime_types->push_back(mime_type);
       }
     }
   }
 
   // Add in plugins by url.
   std::string path = url.path();
   std::string::size_type last_dot = path.rfind('.');
   if (last_dot != std::string::npos) {
     std::string extension = StringToLowerASCII(std::string(path, last_dot+1));
     std::string actual_mime_type;
-    for (size_t i = 0; i < plugin_groups_.size(); ++i) {
-      const std::vector<webkit::WebPluginInfo>& plugins =
-          plugin_groups_[i]->web_plugin_infos();
-      for (size_t i = 0; i < plugins.size(); ++i) {
-        if (SupportsExtension(plugins[i], extension, &actual_mime_type)) {
-          FilePath path = plugins[i].path;
-          if (visited_plugins.insert(path).second &&
-              AllowMimeTypeMismatch(mime_type, actual_mime_type)) {
-            info->push_back(plugins[i]);
-            if (actual_mime_types)
-              actual_mime_types->push_back(actual_mime_type);
-          }
+    for (size_t i = 0; i < plugins_list_.size(); ++i) {
+      if (SupportsExtension(plugins_list_[i], extension, &actual_mime_type)) {
+        FilePath path = plugins_list_[i].path;
+        if (visited_plugins.insert(path).second &&
+            AllowMimeTypeMismatch(mime_type, actual_mime_type)) {
+          info->push_back(plugins_list_[i]);
+          if (actual_mime_types)
+            actual_mime_types->push_back(actual_mime_type);
         }
       }
     }
   }
 }
 
+// TODO(ibraaaa): DELETE
 void PluginList::GetPluginGroups(
     bool load_if_necessary,
     std::vector<PluginGroup>* plugin_groups) {
   if (load_if_necessary)
     LoadPlugins();
   base::AutoLock lock(lock_);
   plugin_groups->clear();
   for (size_t i = 0; i < plugin_groups_.size(); ++i) {
     // In some unit tests we can get confronted with empty groups but in real
     // world code this if should never be false here.
     if (!plugin_groups_[i]->IsEmpty())
       plugin_groups->push_back(*plugin_groups_[i]);
   }
 }
 
+// TODO(ibraaaa): DELETE
 PluginGroup* PluginList::GetPluginGroup(
     const webkit::WebPluginInfo& web_plugin_info) {
   base::AutoLock lock(lock_);
   for (size_t i = 0; i < plugin_groups_.size(); ++i) {
     const std::vector<webkit::WebPluginInfo>& plugins =
         plugin_groups_[i]->web_plugin_infos();
     for (size_t j = 0; j < plugins.size(); ++j) {
       if (plugins[j].path == web_plugin_info.path) {
         return new PluginGroup(*plugin_groups_[i]);
       }
     }
   }
   PluginGroup* group = CreatePluginGroup(web_plugin_info);
   group->AddPlugin(web_plugin_info);
   return group;
 }
 
+// TODO(ibraaaa): DELETE
 string16 PluginList::GetPluginGroupName(const std::string& identifier) {
   for (size_t i = 0; i < plugin_groups_.size(); ++i) {
     if (plugin_groups_[i]->identifier() == identifier)
       return plugin_groups_[i]->GetGroupName();
   }
   return string16();
 }
 
+// TODO(ibraaaa): DELETE
 void PluginList::AddHardcodedPluginGroups(
     const PluginGroupDefinition* group_definitions,
     size_t num_group_definitions) {
   for (size_t i = 0; i < num_group_definitions; ++i) {
     hardcoded_plugin_groups_.push_back(
         PluginGroup::FromPluginGroupDefinition(group_definitions[i]));
   }
 }
 
+// TODO(ibraaaa): DELETE
 PluginGroup* PluginList::AddToPluginGroups(
     const webkit::WebPluginInfo& web_plugin_info,
     ScopedVector<PluginGroup>* plugin_groups) {
   PluginGroup* group = NULL;
   for (size_t i = 0; i < plugin_groups->size(); ++i) {
     if ((*plugin_groups)[i]->Match(web_plugin_info)) {
       group = (*plugin_groups)[i];
       break;
     }
   }
@@ skipping 45 matching lines @@
       if (mime_type.file_extensions[j] == extension) {
         if (actual_mime_type)
           *actual_mime_type = mime_type.mime_type;
         return true;
       }
     }
   }
   return false;
 }
 
+/*static*/
+bool PluginList::RemovePlugin(const FilePath& filename,
+                              std::vector<webkit::WebPluginInfo>* plugins) {
+  bool did_remove = false;
+  for (size_t i = 0; i < plugins->size();) {
+    if ((*plugins)[i].path == filename) {
+      plugins->erase(plugins->begin() + i);
+      did_remove = true;
+    } else {
+      i++;
+    }
+  }
+  return did_remove;
+}
+
 PluginList::~PluginList() {
 }
 
 
 }  // namespace npapi
 }  // namespace webkit