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

chrome/browser/child_process_security_policy.cc

 // Copyright (c) 2009 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/child_process_security_policy.h"
 
 #include "base/file_path.h"
 #include "base/logging.h"
 #include "base/platform_file.h"
 #include "base/stl_util-inl.h"
@@ skipping 133 matching lines @@
                                        security_state_.end());
   security_state_.clear();
 }
 
 // static
 ChildProcessSecurityPolicy* ChildProcessSecurityPolicy::GetInstance() {
   return Singleton<ChildProcessSecurityPolicy>::get();
 }
 
 void ChildProcessSecurityPolicy::Add(int child_id) {
-  AutoLock lock(lock_);
+  base::AutoLock lock(lock_);
   if (security_state_.count(child_id) != 0) {
     NOTREACHED() << "Add child process at most once.";
     return;
   }
 
   security_state_[child_id] = new SecurityState();
 }
 
 void ChildProcessSecurityPolicy::Remove(int child_id) {
-  AutoLock lock(lock_);
+  base::AutoLock lock(lock_);
   if (!security_state_.count(child_id))
     return;  // May be called multiple times.
 
   delete security_state_[child_id];
   security_state_.erase(child_id);
 }
 
 void ChildProcessSecurityPolicy::RegisterWebSafeScheme(
     const std::string& scheme) {
-  AutoLock lock(lock_);
+  base::AutoLock lock(lock_);
   DCHECK(web_safe_schemes_.count(scheme) == 0) << "Add schemes at most once.";
   DCHECK(pseudo_schemes_.count(scheme) == 0) << "Web-safe implies not psuedo.";
 
   web_safe_schemes_.insert(scheme);
 }
 
 bool ChildProcessSecurityPolicy::IsWebSafeScheme(const std::string& scheme) {
-  AutoLock lock(lock_);
+  base::AutoLock lock(lock_);
 
   return (web_safe_schemes_.find(scheme) != web_safe_schemes_.end());
 }
 
 void ChildProcessSecurityPolicy::RegisterPseudoScheme(
     const std::string& scheme) {
-  AutoLock lock(lock_);
+  base::AutoLock lock(lock_);
   DCHECK(pseudo_schemes_.count(scheme) == 0) << "Add schemes at most once.";
   DCHECK(web_safe_schemes_.count(scheme) == 0) <<
       "Psuedo implies not web-safe.";
 
   pseudo_schemes_.insert(scheme);
 }
 
 bool ChildProcessSecurityPolicy::IsPseudoScheme(const std::string& scheme) {
-  AutoLock lock(lock_);
+  base::AutoLock lock(lock_);
 
   return (pseudo_schemes_.find(scheme) != pseudo_schemes_.end());
 }
 
 void ChildProcessSecurityPolicy::GrantRequestURL(
     int child_id, const GURL& url) {
 
   if (!url.is_valid())
     return;  // Can't grant the capability to request invalid URLs.
 
   if (IsWebSafeScheme(url.scheme()))
     return;  // The scheme has already been whitelisted for every child process.
 
   if (IsPseudoScheme(url.scheme())) {
     // The view-source scheme is a special case of a pseudo-URL that eventually
     // results in requesting its embedded URL.
     if (url.SchemeIs(chrome::kViewSourceScheme)) {
       // URLs with the view-source scheme typically look like:
       //   view-source:http://www.google.com/a
       // In order to request these URLs, the child_id needs to be able to
       // request the embedded URL.
       GrantRequestURL(child_id, GURL(url.path()));
     }
 
     return;  // Can't grant the capability to request pseudo schemes.
   }
 
   {
-    AutoLock lock(lock_);
+    base::AutoLock lock(lock_);
     SecurityStateMap::iterator state = security_state_.find(child_id);
     if (state == security_state_.end())
       return;
 
     // If the child process has been commanded to request a scheme, then we
     // grant it the capability to request URLs of that scheme.
     state->second->GrantScheme(url.scheme());
   }
 }
 
 void ChildProcessSecurityPolicy::GrantReadFile(int child_id,
                                                const FilePath& file) {
   GrantPermissionsForFile(child_id, file, kReadFilePermissions);
 }
 
 void ChildProcessSecurityPolicy::GrantPermissionsForFile(
     int child_id, const FilePath& file, int permissions) {
-  AutoLock lock(lock_);
+  base::AutoLock lock(lock_);
 
   SecurityStateMap::iterator state = security_state_.find(child_id);
   if (state == security_state_.end())
     return;
 
   state->second->GrantPermissionsForFile(file, permissions);
 }
 
 void ChildProcessSecurityPolicy::RevokeAllPermissionsForFile(
     int child_id, const FilePath& file) {
-  AutoLock lock(lock_);
+  base::AutoLock lock(lock_);
 
   SecurityStateMap::iterator state = security_state_.find(child_id);
   if (state == security_state_.end())
     return;
 
   state->second->RevokeAllPermissionsForFile(file);
 }
 
 void ChildProcessSecurityPolicy::GrantScheme(int child_id,
                                              const std::string& scheme) {
-  AutoLock lock(lock_);
+  base::AutoLock lock(lock_);
 
   SecurityStateMap::iterator state = security_state_.find(child_id);
   if (state == security_state_.end())
     return;
 
   state->second->GrantScheme(scheme);
 }
 
 void ChildProcessSecurityPolicy::GrantDOMUIBindings(int child_id) {
-  AutoLock lock(lock_);
+  base::AutoLock lock(lock_);
 
   SecurityStateMap::iterator state = security_state_.find(child_id);
   if (state == security_state_.end())
     return;
 
   state->second->GrantBindings(BindingsPolicy::DOM_UI);
 
   // DOM UI bindings need the ability to request chrome: URLs.
   state->second->GrantScheme(chrome::kChromeUIScheme);
 
   // DOM UI pages can contain links to file:// URLs.
   state->second->GrantScheme(chrome::kFileScheme);
 }
 
 void ChildProcessSecurityPolicy::GrantExtensionBindings(int child_id) {
-  AutoLock lock(lock_);
+  base::AutoLock lock(lock_);
 
   SecurityStateMap::iterator state = security_state_.find(child_id);
   if (state == security_state_.end())
     return;
 
   state->second->GrantBindings(BindingsPolicy::EXTENSION);
 }
 
 void ChildProcessSecurityPolicy::GrantReadRawCookies(int child_id) {
-  AutoLock lock(lock_);
+  base::AutoLock lock(lock_);
 
   SecurityStateMap::iterator state = security_state_.find(child_id);
   if (state == security_state_.end())
     return;
 
   state->second->GrantReadRawCookies();
 }
 
 void ChildProcessSecurityPolicy::RevokeReadRawCookies(int child_id) {
-  AutoLock lock(lock_);
+  base::AutoLock lock(lock_);
 
   SecurityStateMap::iterator state = security_state_.find(child_id);
   if (state == security_state_.end())
     return;
 
   state->second->RevokeReadRawCookies();
 }
 
 bool ChildProcessSecurityPolicy::CanRequestURL(
     int child_id, const GURL& url) {
@@ skipping 23 matching lines @@
     // URLs like <about:memory> and <about:crash> shouldn't be requestable by
     // any child process.  Also, this case covers <javascript:...>, which should
     // be handled internally by the process and not kicked up to the browser.
     return false;
   }
 
   if (!net::URLRequest::IsHandledURL(url))
     return true;  // This URL request is destined for ShellExecute.
 
   {
-    AutoLock lock(lock_);
+    base::AutoLock lock(lock_);
 
     SecurityStateMap::iterator state = security_state_.find(child_id);
     if (state == security_state_.end())
       return false;
 
     // Otherwise, we consult the child process's security state to see if it is
     // allowed to request the URL.
     return state->second->CanRequestURL(url);
   }
 }
 
 bool ChildProcessSecurityPolicy::CanReadFile(int child_id,
                                              const FilePath& file) {
   return HasPermissionsForFile(child_id, file, kReadFilePermissions);
 }
 
 bool ChildProcessSecurityPolicy::HasPermissionsForFile(
     int child_id, const FilePath& file, int permissions) {
-  AutoLock lock(lock_);
+  base::AutoLock lock(lock_);
 
   SecurityStateMap::iterator state = security_state_.find(child_id);
   if (state == security_state_.end())
     return false;
 
   return state->second->HasPermissionsForFile(file, permissions);
 }
 
 bool ChildProcessSecurityPolicy::HasDOMUIBindings(int child_id) {
-  AutoLock lock(lock_);
+  base::AutoLock lock(lock_);
 
   SecurityStateMap::iterator state = security_state_.find(child_id);
   if (state == security_state_.end())
     return false;
 
   return state->second->has_dom_ui_bindings();
 }
 
 bool ChildProcessSecurityPolicy::HasExtensionBindings(int child_id) {
-  AutoLock lock(lock_);
+  base::AutoLock lock(lock_);
 
   SecurityStateMap::iterator state = security_state_.find(child_id);
   if (state == security_state_.end())
     return false;
 
   return state->second->has_extension_bindings();
 }
 
 bool ChildProcessSecurityPolicy::CanReadRawCookies(int child_id) {
-  AutoLock lock(lock_);
+  base::AutoLock lock(lock_);
 
   SecurityStateMap::iterator state = security_state_.find(child_id);
   if (state == security_state_.end())
     return false;
 
   return state->second->can_read_raw_cookies();
 }