Upating the app, ceee, chrome, ipc, media, and net directories to use the correct lock.h file.

webkit/plugins/npapi/plugin_list.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 "webkit/plugins/npapi/plugin_list.h"
 
 #include <algorithm>
 
 #include "base/command_line.h"
 #include "base/lazy_instance.h"
@@ skipping 164 matching lines @@
   return g_singleton.Pointer();
 }
 
 // static
 bool PluginList::DebugPluginLoading() {
   return CommandLine::ForCurrentProcess()->HasSwitch(
       switches::kDebugPluginLoading);
 }
 
 bool PluginList::PluginsLoaded() {
-  AutoLock lock(lock_);
+  base::AutoLock lock(lock_);
   return plugins_loaded_;
 }
 
 void PluginList::RefreshPlugins() {
-  AutoLock lock(lock_);
+  base::AutoLock lock(lock_);
   plugins_need_refresh_ = true;
 }
 
 void PluginList::AddExtraPluginPath(const FilePath& plugin_path) {
   // Chrome OS only loads plugins from /opt/google/chrome/plugins.
 #if !defined(OS_CHROMEOS)
-  AutoLock lock(lock_);
+  base::AutoLock lock(lock_);
   extra_plugin_paths_.push_back(plugin_path);
 #endif
 }
 
 void PluginList::RemoveExtraPluginPath(const FilePath& plugin_path) {
-  AutoLock lock(lock_);
+  base::AutoLock lock(lock_);
   std::vector<FilePath>::iterator it =
       std::find(extra_plugin_paths_.begin(), extra_plugin_paths_.end(),
                 plugin_path);
   if (it != extra_plugin_paths_.end())
     extra_plugin_paths_.erase(it);
 }
 
 void PluginList::AddExtraPluginDir(const FilePath& plugin_dir) {
   // Chrome OS only loads plugins from /opt/google/chrome/plugins.
 #if !defined(OS_CHROMEOS)
-  AutoLock lock(lock_);
+  base::AutoLock lock(lock_);
   extra_plugin_dirs_.push_back(plugin_dir);
 #endif
 }
 
 void PluginList::RegisterInternalPlugin(const PluginVersionInfo& info) {
-  AutoLock lock(lock_);
+  base::AutoLock lock(lock_);
   internal_plugins_.push_back(info);
 }
 
 void PluginList::RegisterInternalPlugin(const FilePath& path) {
   webkit::npapi::PluginVersionInfo info;
   info.path = path;
   memset(&info.entry_points, 0, sizeof(info.entry_points));
   RegisterInternalPlugin(info);
 }
 
 void PluginList::RegisterInternalPlugin(const FilePath& filename,
                                         const std::string& name,
                                         const std::string& description,
                                         const std::string& mime_type,
                                         const PluginEntryPoints& entry_points) {
   webkit::npapi::PluginVersionInfo info = {
     filename,
     ASCIIToWide(name),
     ASCIIToWide(description),
     L"1",
     ASCIIToWide(mime_type),
     L"",
     L"",
     entry_points
   };
   RegisterInternalPlugin(info);
 }
 
 void PluginList::UnregisterInternalPlugin(const FilePath& path) {
-  AutoLock lock(lock_);
+  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();
 }
 
 bool PluginList::ReadPluginInfo(const FilePath& filename,
                                 WebPluginInfo* info,
                                 const PluginEntryPoints** entry_points) {
   {
-    AutoLock lock(lock_);
+    base::AutoLock lock(lock_);
     for (size_t i = 0; i < internal_plugins_.size(); ++i) {
       if (filename == internal_plugins_[i].path) {
         *entry_points = &internal_plugins_[i].entry_points;
         return CreateWebPluginInfo(internal_plugins_[i], info);
       }
     }
   }
 
   // Not an internal plugin.
   *entry_points = NULL;
@@ skipping 53 matching lines @@
 PluginList::PluginList()
     : plugins_loaded_(false),
       plugins_need_refresh_(false),
       disable_outdated_plugins_(false),
       next_priority_(0) {
   PlatformInit();
   AddHardcodedPluginGroups();
 }
 
 bool PluginList::ShouldDisableGroup(const string16& group_name) {
-  AutoLock lock(lock_);
+  base::AutoLock lock(lock_);
   if (PluginGroup::IsPluginNameDisabledByPolicy(group_name)) {
     disabled_groups_.insert(group_name);
     return true;
   }
   return disabled_groups_.count(group_name) > 0;
 }
 
 void PluginList::LoadPlugins(bool refresh) {
   // 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;
   std::vector<PluginVersionInfo> internal_plugins;
   {
-    AutoLock lock(lock_);
+    base::AutoLock lock(lock_);
     if (plugins_loaded_ && !refresh && !plugins_need_refresh_)
       return;
 
     // Clear the refresh bit now, because it might get set again before we
     // reach the end of the method.
     plugins_need_refresh_ = false;
     extra_plugin_paths = extra_plugin_paths_;
     extra_plugin_dirs = extra_plugin_dirs_;
     internal_plugins = internal_plugins_;
   }
@@ skipping 47 matching lines @@
     PluginGroup* group = it->second;
     string16 group_name = group->GetGroupName();
     if (ShouldDisableGroup(group_name)) {
       group->Enable(false);
     }
 
     if (disable_outdated_plugins_) {
       group->DisableOutdatedPlugins();
     }
     if (!group->Enabled()) {
-      AutoLock lock(lock_);
+      base::AutoLock lock(lock_);
       disabled_groups_.insert(group_name);
     }
   }
 
   // Only update the data now since loading plugins can take a while.
-  AutoLock lock(lock_);
+  base::AutoLock lock(lock_);
 
   plugins_ = new_plugins;
   plugins_loaded_ = true;
 }
 
 void PluginList::LoadPlugin(const FilePath& path,
                             std::vector<WebPluginInfo>* plugins) {
   LOG_IF(ERROR, PluginList::DebugPluginLoading())
       << "Loading plugin " << path.value();
 
@@ skipping 22 matching lines @@
   }
 
   // Mark disabled plugins as such. (This has to happen before calling
   // |AddToPluginGroups(plugin_info)|.)
   if (disabled_plugins_.count(plugin_info.path)) {
     plugin_info.enabled = false;
   } else {
     plugin_info.enabled = true;
   }
 
-  AutoLock lock(lock_);
+  base::AutoLock lock(lock_);
   plugins->push_back(plugin_info);
   AddToPluginGroups(plugin_info);
 }
 
 bool PluginList::SupportsType(const WebPluginInfo& info,
                               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;
@@ skipping 24 matching lines @@
     }
   }
 
   return false;
 }
 
 
 void PluginList::GetPlugins(bool refresh, std::vector<WebPluginInfo>* plugins) {
   LoadPlugins(refresh);
 
-  AutoLock lock(lock_);
+  base::AutoLock lock(lock_);
   *plugins = plugins_;
 }
 
 void PluginList::GetEnabledPlugins(bool refresh,
                                    std::vector<WebPluginInfo>* plugins) {
   LoadPlugins(refresh);
 
   plugins->clear();
-  AutoLock lock(lock_);
+  base::AutoLock lock(lock_);
   for (std::vector<WebPluginInfo>::const_iterator it = plugins_.begin();
        it != plugins_.end();
        ++it) {
     if (it->enabled)
       plugins->push_back(*it);
   }
 }
 
 void PluginList::GetPluginInfoArray(
     const GURL& url,
     const std::string& mime_type,
     bool allow_wildcard,
     std::vector<WebPluginInfo>* info,
     std::vector<std::string>* actual_mime_types) {
   DCHECK(mime_type == StringToLowerASCII(mime_type));
   DCHECK(info);
 
   LoadPlugins(false);
-  AutoLock lock(lock_);
+  base::AutoLock lock(lock_);
   info->clear();
   if (actual_mime_types)
     actual_mime_types->clear();
 
   std::set<FilePath> visited_plugins;
 
   // Add in enabled plugins by mime type.
   WebPluginInfo default_plugin;
   for (size_t i = 0; i < plugins_.size(); ++i) {
     if (plugins_[i].enabled &&
@@ skipping 79 matching lines @@
       *info = info_list[0];
       return true;
     }
   }
   return false;
 }
 
 bool PluginList::GetPluginInfoByPath(const FilePath& plugin_path,
                                      WebPluginInfo* info) {
   LoadPlugins(false);
-  AutoLock lock(lock_);
+  base::AutoLock lock(lock_);
   for (size_t i = 0; i < plugins_.size(); ++i) {
     if (plugins_[i].path == plugin_path) {
       *info = plugins_[i];
       return true;
     }
   }
 
   return false;
 }
 
 void PluginList::GetPluginGroups(
     bool load_if_necessary,
     std::vector<PluginGroup>* plugin_groups) {
   if (load_if_necessary)
     LoadPlugins(false);
   plugin_groups->clear();
   for (PluginGroup::PluginMap::const_iterator it = plugin_groups_.begin();
        it != plugin_groups_.end(); ++it) {
     if (!it->second->IsEmpty())
       plugin_groups->push_back(*it->second);
   }
 }
 
 const PluginGroup* PluginList::GetPluginGroup(
     const WebPluginInfo& web_plugin_info) {
-  AutoLock lock(lock_);
+  base::AutoLock lock(lock_);
   return AddToPluginGroups(web_plugin_info);
 }
 
 string16 PluginList::GetPluginGroupName(std::string identifier) {
   PluginGroup::PluginMap::iterator it = plugin_groups_.find(identifier);
   if (it == plugin_groups_.end()) {
     return string16();
   }
   return it->second->GetGroupName();
 }
 
 std::string PluginList::GetPluginGroupIdentifier(
     const WebPluginInfo& web_plugin_info) {
-  AutoLock lock(lock_);
+  base::AutoLock lock(lock_);
   PluginGroup* group = AddToPluginGroups(web_plugin_info);
   return group->identifier();
 }
 
 void PluginList::AddHardcodedPluginGroups() {
-  AutoLock lock(lock_);
+  base::AutoLock lock(lock_);
   const PluginGroupDefinition* definitions = GetPluginGroupDefinitions();
   for (size_t i = 0; i < GetPluginGroupDefinitionsSize(); ++i) {
     PluginGroup* definition_group = PluginGroup::FromPluginGroupDefinition(
         definitions[i]);
     std::string identifier = definition_group->identifier();
     DCHECK(plugin_groups_.find(identifier) == plugin_groups_.end());
     plugin_groups_.insert(std::make_pair(identifier, definition_group));
   }
 }
 
@@ skipping 17 matching lines @@
     if (plugin_groups_.find(identifier) != plugin_groups_.end())
       identifier = PluginGroup::GetLongIdentifier(web_plugin_info);
     DCHECK(plugin_groups_.find(identifier) == plugin_groups_.end());
     plugin_groups_.insert(std::make_pair(identifier, group));
   }
   group->AddPlugin(web_plugin_info, next_priority_++);
   return group;
 }
 
 bool PluginList::EnablePlugin(const FilePath& filename) {
-  AutoLock lock(lock_);
+  base::AutoLock lock(lock_);
 
   bool did_enable = false;
 
   std::set<FilePath>::iterator entry = disabled_plugins_.find(filename);
   if (entry == disabled_plugins_.end())
     return did_enable;  // Early exit if plugin not in disabled list.
 
   disabled_plugins_.erase(entry);  // Remove from disabled list.
 
   // Set enabled flags if necessary.
   for (std::vector<WebPluginInfo>::iterator it = plugins_.begin();
        it != plugins_.end();
        ++it) {
     if (it->path == filename) {
       DCHECK(!it->enabled);  // Should have been disabled.
       it->enabled = true;
       did_enable = true;
     }
   }
 
   return did_enable;
 }
 
 bool PluginList::DisablePlugin(const FilePath& filename) {
-  AutoLock lock(lock_);
+  base::AutoLock lock(lock_);
 
   bool did_disable = false;
 
   if (disabled_plugins_.find(filename) != disabled_plugins_.end())
     return did_disable;  // Early exit if plugin already in disabled list.
 
   disabled_plugins_.insert(filename);  // Add to disabled list.
 
   // Unset enabled flags if necessary.
   for (std::vector<WebPluginInfo>::iterator it = plugins_.begin();
        it != plugins_.end();
        ++it) {
     if (it->path == filename) {
       DCHECK(it->enabled);  // Should have been enabled.
       it->enabled = false;
       did_disable = true;
     }
   }
 
   return did_disable;
 }
 
 bool PluginList::EnableGroup(bool enable, const string16& group_name) {
   bool did_change = false;
   {
-    AutoLock lock(lock_);
+    base::AutoLock lock(lock_);
 
     std::set<string16>::iterator entry = disabled_groups_.find(group_name);
     if (enable) {
       if (entry == disabled_groups_.end())
         return did_change;  // Early exit if group not in disabled list.
       disabled_groups_.erase(entry);  // Remove from disabled list.
     } else {
       if (entry != disabled_groups_.end())
         return did_change;  // Early exit if group already in disabled list.
       disabled_groups_.insert(group_name);
@@ skipping 22 matching lines @@
   Shutdown();
 }
 
 void PluginList::Shutdown() {
   STLDeleteContainerPairSecondPointers(plugin_groups_.begin(),
                                        plugin_groups_.end());
 }
 
 }  // namespace npapi
 }  // namespace webkit