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

net/base/cookie_monster.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.
 
 // Portions of this code based on Mozilla:
 //   (netwerk/cookie/src/nsCookieService.cpp)
 /* ***** BEGIN LICENSE BLOCK *****
  * Version: MPL 1.1/GPL 2.0/LGPL 2.1
  *
  * The contents of this file are subject to the Mozilla Public License Version
@@ skipping 485 matching lines @@
 }
 
 bool CookieMonster::DomainIsHostOnly(const std::string& domain_string) {
   return (domain_string.empty() || domain_string[0] != '.');
 }
 
 bool CookieMonster::SetCookieWithDetails(
     const GURL& url, const std::string& name, const std::string& value,
     const std::string& domain, const std::string& path,
     const base::Time& expiration_time, bool secure, bool http_only) {
-  AutoLock autolock(lock_);
+  base::AutoLock autolock(lock_);
 
   if (!HasCookieableScheme(url))
     return false;
 
   InitIfNecessary();
 
   Time creation_time = CurrentTime();
   last_time_seen_ = creation_time;
 
   scoped_ptr<CanonicalCookie> cc;
   cc.reset(CanonicalCookie::Create(
       url, name, value, domain, path,
       creation_time, expiration_time,
       secure, http_only));
 
   if (!cc.get())
     return false;
 
   CookieOptions options;
   options.set_include_httponly();
   return SetCanonicalCookie(&cc, creation_time, options);
 }
 
 
 CookieList CookieMonster::GetAllCookies() {
-  AutoLock autolock(lock_);
+  base::AutoLock autolock(lock_);
   InitIfNecessary();
 
   // This function is being called to scrape the cookie list for management UI
   // or similar.  We shouldn't show expired cookies in this list since it will
   // just be confusing to users, and this function is called rarely enough (and
   // is already slow enough) that it's OK to take the time to garbage collect
   // the expired cookies now.
   //
   // Note that this does not prune cookies to be below our limits (if we've
   // exceeded them) the way that calling GarbageCollect() would.
@@ skipping 14 matching lines @@
   for (std::vector<CanonicalCookie*>::const_iterator it = cookie_ptrs.begin();
        it != cookie_ptrs.end(); ++it)
     cookie_list.push_back(**it);
 
   return cookie_list;
 }
 
 CookieList CookieMonster::GetAllCookiesForURLWithOptions(
     const GURL& url,
     const CookieOptions& options) {
-  AutoLock autolock(lock_);
+  base::AutoLock autolock(lock_);
   InitIfNecessary();
 
   std::vector<CanonicalCookie*> cookie_ptrs;
   FindCookiesForHostAndDomain(url, options, false, &cookie_ptrs);
   std::sort(cookie_ptrs.begin(), cookie_ptrs.end(), CookieSorter);
 
   CookieList cookies;
   for (std::vector<CanonicalCookie*>::const_iterator it = cookie_ptrs.begin();
        it != cookie_ptrs.end(); it++)
     cookies.push_back(**it);
 
   return cookies;
 }
 
 CookieList CookieMonster::GetAllCookiesForURL(const GURL& url) {
   CookieOptions options;
   options.set_include_httponly();
 
   return GetAllCookiesForURLWithOptions(url, options);
 }
 
 int CookieMonster::DeleteAll(bool sync_to_store) {
-  AutoLock autolock(lock_);
+  base::AutoLock autolock(lock_);
   if (sync_to_store)
     InitIfNecessary();
 
   int num_deleted = 0;
   for (CookieMap::iterator it = cookies_.begin(); it != cookies_.end();) {
     CookieMap::iterator curit = it;
     ++it;
     InternalDeleteCookie(curit, sync_to_store,
                          sync_to_store ? DELETE_COOKIE_EXPLICIT :
                              DELETE_COOKIE_DONT_RECORD /* Destruction. */);
     ++num_deleted;
   }
 
   return num_deleted;
 }
 
 int CookieMonster::DeleteAllCreatedBetween(const Time& delete_begin,
                                            const Time& delete_end,
                                            bool sync_to_store) {
-  AutoLock autolock(lock_);
+  base::AutoLock autolock(lock_);
   InitIfNecessary();
 
   int num_deleted = 0;
   for (CookieMap::iterator it = cookies_.begin(); it != cookies_.end();) {
     CookieMap::iterator curit = it;
     CanonicalCookie* cc = curit->second;
     ++it;
 
     if (cc->CreationDate() >= delete_begin &&
         (delete_end.is_null() || cc->CreationDate() < delete_end)) {
       InternalDeleteCookie(curit, sync_to_store, DELETE_COOKIE_EXPLICIT);
       ++num_deleted;
     }
   }
 
   return num_deleted;
 }
 
 int CookieMonster::DeleteAllCreatedAfter(const Time& delete_begin,
                                          bool sync_to_store) {
   return DeleteAllCreatedBetween(delete_begin, Time(), sync_to_store);
 }
 
 int CookieMonster::DeleteAllForHost(const GURL& url) {
-  AutoLock autolock(lock_);
+  base::AutoLock autolock(lock_);
   InitIfNecessary();
 
   if (!HasCookieableScheme(url))
     return 0;
 
   const std::string scheme(url.scheme());
   const std::string host(url.host());
 
   // We store host cookies in the store by their canonical host name;
   // domain cookies are stored with a leading ".".  So this is a pretty
@@ skipping 10 matching lines @@
     if (cc->IsHostCookie() && cc->IsDomainMatch(scheme, host)) {
       num_deleted++;
 
       InternalDeleteCookie(curit, true, DELETE_COOKIE_EXPLICIT);
     }
   }
   return num_deleted;
 }
 
 bool CookieMonster::DeleteCanonicalCookie(const CanonicalCookie& cookie) {
-  AutoLock autolock(lock_);
+  base::AutoLock autolock(lock_);
   InitIfNecessary();
 
   for (CookieMapItPair its = cookies_.equal_range(GetKey(cookie.Domain()));
        its.first != its.second; ++its.first) {
     // The creation date acts as our unique index...
     if (its.first->second->CreationDate() == cookie.CreationDate()) {
       InternalDeleteCookie(its.first, true, DELETE_COOKIE_EXPLICIT);
       return true;
     }
   }
   return false;
 }
 
 void CookieMonster::SetCookieableSchemes(
     const char* schemes[], size_t num_schemes) {
-  AutoLock autolock(lock_);
+  base::AutoLock autolock(lock_);
 
   // Cookieable Schemes must be set before first use of function.
   DCHECK(!initialized_);
 
   cookieable_schemes_.clear();
   cookieable_schemes_.insert(cookieable_schemes_.end(),
                              schemes, schemes + num_schemes);
 }
 
 void CookieMonster::SetExpiryAndKeyScheme(ExpiryAndKeyScheme key_scheme) {
   DCHECK(!initialized_);
   expiry_and_key_scheme_ = key_scheme;
 }
 
 void CookieMonster::SetClearPersistentStoreOnExit(bool clear_local_store) {
   if(store_)
     store_->SetClearLocalStateOnExit(clear_local_store);
 }
 
 // static
 void CookieMonster::EnableFileScheme() {
   enable_file_scheme_ = true;
 }
 
 void CookieMonster::FlushStore(Task* completion_task) {
-  AutoLock autolock(lock_);
+  base::AutoLock autolock(lock_);
   if (initialized_ && store_)
     store_->Flush(completion_task);
   else if (completion_task)
     MessageLoop::current()->PostTask(FROM_HERE, completion_task);
 }
 
 bool CookieMonster::SetCookieWithOptions(const GURL& url,
                                          const std::string& cookie_line,
                                          const CookieOptions& options) {
-  AutoLock autolock(lock_);
+  base::AutoLock autolock(lock_);
 
   if (!HasCookieableScheme(url)) {
     return false;
   }
 
   InitIfNecessary();
 
   return SetCookieWithCreationTimeAndOptions(url, cookie_line, Time(), options);
 }
 
 std::string CookieMonster::GetCookiesWithOptions(const GURL& url,
                                                  const CookieOptions& options) {
-  AutoLock autolock(lock_);
+  base::AutoLock autolock(lock_);
   InitIfNecessary();
 
   if (!HasCookieableScheme(url)) {
     return std::string();
   }
 
   TimeTicks start_time(TimeTicks::Now());
 
   // Get the cookies for this host and its domain(s).
   std::vector<CanonicalCookie*> cookies;
@@ skipping 15 matching lines @@
 
   histogram_time_get_->AddTime(TimeTicks::Now() - start_time);
 
   VLOG(kVlogGetCookies) << "GetCookies() result: " << cookie_line;
 
   return cookie_line;
 }
 
 void CookieMonster::DeleteCookie(const GURL& url,
                                  const std::string& cookie_name) {
-  AutoLock autolock(lock_);
+  base::AutoLock autolock(lock_);
   InitIfNecessary();
 
   if (!HasCookieableScheme(url))
     return;
 
   CookieOptions options;
   options.set_include_httponly();
   // Get the cookies for this host and its domain(s).
   std::vector<CanonicalCookie*> cookies;
   FindCookiesForHostAndDomain(url, options, true, &cookies);
@@ skipping 21 matching lines @@
   return this;
 }
 
 CookieMonster::~CookieMonster() {
   DeleteAll(false);
 }
 
 bool CookieMonster::SetCookieWithCreationTime(const GURL& url,
                                               const std::string& cookie_line,
                                               const base::Time& creation_time) {
-  AutoLock autolock(lock_);
+  base::AutoLock autolock(lock_);
 
   if (!HasCookieableScheme(url)) {
     return false;
   }
 
   InitIfNecessary();
   return SetCookieWithCreationTimeAndOptions(url, cookie_line, creation_time,
                                              CookieOptions());
 }
 
@@ skipping 1195 matching lines @@
 std::string CookieMonster::CanonicalCookie::DebugString() const {
   return base::StringPrintf(
       "name: %s value: %s domain: %s path: %s creation: %"
       PRId64,
       name_.c_str(), value_.c_str(),
       domain_.c_str(), path_.c_str(),
       static_cast<int64>(creation_date_.ToTimeT()));
 }
 
 }  // namespace