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

chrome/browser/safe_browsing/safe_browsing_database.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/safe_browsing/safe_browsing_database.h"
 
 #include "base/file_util.h"
 #include "base/metrics/histogram.h"
 #include "base/metrics/stats_counters.h"
 #include "base/time.h"
@@ skipping 269 matching lines @@
   DCHECK_EQ(creation_loop_, MessageLoop::current());
 }
 
 void SafeBrowsingDatabaseNew::Init(const FilePath& filename_base) {
   DCHECK_EQ(creation_loop_, MessageLoop::current());
 
   // NOTE: There is no need to grab the lock in this function, since
   // until it returns, there are no pointers to this class on other
   // threads.  Then again, that means there is no possibility of
   // contention on the lock...
-  AutoLock locked(lookup_lock_);
+  base::AutoLock locked(lookup_lock_);
 
   DCHECK(browse_filename_.empty());  // Ensure we haven't been run before.
   DCHECK(download_filename_.empty());  // Ensure we haven't been run before.
 
   browse_filename_ = BrowseDBFilename(filename_base);
   browse_store_->Init(
       browse_filename_,
       NewCallback(this, &SafeBrowsingDatabaseNew::HandleCorruptDatabase));
 
   full_browse_hashes_.clear();
@@ skipping 16 matching lines @@
   DCHECK_EQ(creation_loop_, MessageLoop::current());
 
   // Delete files on disk.
   // TODO(shess): Hard to see where one might want to delete without a
   // reset.  Perhaps inline |Delete()|?
   if (!Delete())
     return false;
 
   // Reset objects in memory.
   {
-    AutoLock locked(lookup_lock_);
+    base::AutoLock locked(lookup_lock_);
     full_browse_hashes_.clear();
     pending_browse_hashes_.clear();
     prefix_miss_cache_.clear();
     // TODO(shess): This could probably be |bloom_filter_.reset()|.
     browse_bloom_filter_ = new BloomFilter(BloomFilter::kBloomFilterMinSize *
                                            BloomFilter::kBloomFilterSizeRatio);
   }
 
   return true;
 }
@@ skipping 10 matching lines @@
   prefix_hits->clear();
   full_hits->clear();
 
   std::vector<SBPrefix> prefixes;
   BrowsePrefixesToCheck(url, &prefixes);
   if (prefixes.empty())
     return false;
 
   // This function is called on the I/O thread, prevent changes to
   // bloom filter and caches.
-  AutoLock locked(lookup_lock_);
+  base::AutoLock locked(lookup_lock_);
 
   if (!browse_bloom_filter_.get())
     return false;
 
   size_t miss_count = 0;
   for (size_t i = 0; i < prefixes.size(); ++i) {
     if (browse_bloom_filter_->Exists(prefixes[i])) {
       prefix_hits->push_back(prefixes[i]);
       if (prefix_miss_cache_.count(prefixes[i]) > 0)
         ++miss_count;
@@ skipping 231 matching lines @@
       else
         store->DeleteAddChunk(encoded_chunk_id);
     }
   }
 }
 
 void SafeBrowsingDatabaseNew::CacheHashResults(
     const std::vector<SBPrefix>& prefixes,
     const std::vector<SBFullHashResult>& full_hits) {
   // This is called on the I/O thread, lock against updates.
-  AutoLock locked(lookup_lock_);
+  base::AutoLock locked(lookup_lock_);
 
   if (full_hits.empty()) {
     prefix_miss_cache_.insert(prefixes.begin(), prefixes.end());
     return;
   }
 
   // TODO(shess): SBFullHashResult and SBAddFullHash are very similar.
   // Refactor to make them identical.
   const base::Time now = base::Time::Now();
   const size_t orig_size = pending_browse_hashes_.size();
@@ skipping 101 matching lines @@
                                     &add_full_hashes_result))
     RecordFailure(FAILURE_DOWNLOAD_DATABASE_UPDATE_FINISH);
   return;
 }
 
 void SafeBrowsingDatabaseNew::UpdateBrowseStore() {
   // Copy out the pending add hashes.  Copy rather than swapping in
   // case |ContainsBrowseURL()| is called before the new filter is complete.
   std::vector<SBAddFullHash> pending_add_hashes;
   {
-    AutoLock locked(lookup_lock_);
+    base::AutoLock locked(lookup_lock_);
     pending_add_hashes.insert(pending_add_hashes.end(),
                               pending_browse_hashes_.begin(),
                               pending_browse_hashes_.end());
   }
 
   // Measure the amount of IO during the bloom filter build.
   base::IoCounters io_before, io_after;
   base::ProcessHandle handle = base::Process::Current().handle();
   scoped_ptr<base::ProcessMetrics> metric(
 #if !defined(OS_MACOSX)
@@ skipping 28 matching lines @@
   for (size_t i = 0; i < add_prefixes.size(); ++i) {
     filter->Insert(add_prefixes[i].prefix);
   }
 
   // This needs to be in sorted order by prefix for efficient access.
   std::sort(add_full_hashes.begin(), add_full_hashes.end(),
             SBAddFullHashPrefixLess);
 
   // Swap in the newly built filter and cache.
   {
-    AutoLock locked(lookup_lock_);
+    base::AutoLock locked(lookup_lock_);
     full_browse_hashes_.swap(add_full_hashes);
 
     // TODO(shess): If |CacheHashResults()| is posted between the
     // earlier lock and this clear, those pending hashes will be lost.
     // It could be fixed by only removing hashes which were collected
     // at the earlier point.  I believe that is fail-safe as-is (the
     // hash will be fetched again).
     pending_browse_hashes_.clear();
     prefix_miss_cache_.clear();
     browse_bloom_filter_.swap(filter);
@@ skipping 106 matching lines @@
     return;
 
   const base::TimeTicks before = base::TimeTicks::Now();
   const bool write_ok = browse_bloom_filter_->WriteFile(bloom_filter_filename_);
   DVLOG(1) << "SafeBrowsingDatabaseNew wrote bloom filter in "
            << (base::TimeTicks::Now() - before).InMilliseconds() << " ms";
 
   if (!write_ok)
     RecordFailure(FAILURE_DATABASE_FILTER_WRITE);
 }