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

chrome/browser/history/top_sites.cc

 // Copyright (c) 2011 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/history/top_sites.h"
 
 #include <algorithm>
 #include <set>
 
 #include "app/l10n_util.h"
@@ skipping 207 matching lines @@
 void TopSites::GetMostVisitedURLs(CancelableRequestConsumer* consumer,
                                   GetTopSitesCallback* callback) {
   // WARNING: this may be invoked on any thread.
   scoped_refptr<CancelableRequest<GetTopSitesCallback> > request(
       new CancelableRequest<GetTopSitesCallback>(callback));
   // This ensures cancellation of requests when either the consumer or the
   // provider is deleted. Deletion of requests is also guaranteed.
   AddRequest(request, consumer);
   MostVisitedURLList filtered_urls;
   {
-    AutoLock lock(lock_);
+    base::AutoLock lock(lock_);
     if (!loaded_) {
       // A request came in before we finished loading. Put the request in
       // pending_callbacks_ and we'll notify it when we finish loading.
       pending_callbacks_.insert(request);
       return;
     }
 
     filtered_urls = thread_safe_cache_->top_sites();
   }
   request->ForwardResult(GetTopSitesCallback::TupleType(filtered_urls));
 }
 
 bool TopSites::GetPageThumbnail(const GURL& url,
                                 scoped_refptr<RefCountedBytes>* bytes) {
   // WARNING: this may be invoked on any thread.
-  AutoLock lock(lock_);
+  base::AutoLock lock(lock_);
   return thread_safe_cache_->GetPageThumbnail(url, bytes);
 }
 
 // Returns the index of |url| in |urls|, or -1 if not found.
 static int IndexOf(const MostVisitedURLList& urls, const GURL& url) {
   for (size_t i = 0; i < urls.size(); i++) {
     if (urls[i].url == url)
       return i;
   }
   return -1;
@@ skipping 546 matching lines @@
 
   return kTopSitesNumber + blacklist_->size();
 }
 
 void TopSites::MoveStateToLoaded() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   MostVisitedURLList filtered_urls;
   PendingCallbackSet pending_callbacks;
   {
-    AutoLock lock(lock_);
+    base::AutoLock lock(lock_);
 
     if (loaded_)
       return;  // Don't do anything if we're already loaded.
     loaded_ = true;
 
     // Now that we're loaded we can service the queued up callbacks. Copy them
     // here and service them outside the lock.
     if (!pending_callbacks_.empty()) {
       filtered_urls = thread_safe_cache_->top_sites();
       pending_callbacks.swap(pending_callbacks_);
     }
   }
 
   ProcessPendingCallbacks(pending_callbacks, filtered_urls);
 
   NotificationService::current()->Notify(NotificationType::TOP_SITES_LOADED,
                                          Source<Profile>(profile_),
                                          Details<TopSites>(this));
 }
 
 void TopSites::ResetThreadSafeCache() {
-  AutoLock lock(lock_);
+  base::AutoLock lock(lock_);
   MostVisitedURLList cached;
   ApplyBlacklistAndPinnedURLs(cache_->top_sites(), &cached);
   thread_safe_cache_->SetTopSites(cached);
 }
 
 void TopSites::ResetThreadSafeImageCache() {
-  AutoLock lock(lock_);
+  base::AutoLock lock(lock_);
   thread_safe_cache_->SetThumbnails(cache_->images());
   thread_safe_cache_->RemoveUnreferencedThumbnails();
 }
 
 void TopSites::RestartQueryForTopSitesTimer(base::TimeDelta delta) {
   if (timer_.IsRunning() && ((timer_start_time_ + timer_.GetCurrentDelay()) <
                              (base::TimeTicks::Now() + delta))) {
     return;
   }
 
@@ skipping 59 matching lines @@
   SetTopSites(pages);
 
   // Used only in testing.
   NotificationService::current()->Notify(
       NotificationType::TOP_SITES_UPDATED,
       Source<TopSites>(this),
       Details<CancelableRequestProvider::Handle>(&handle));
 }
 
 }  // namespace history