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

chrome/browser/bookmarks/bookmark_model.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/bookmarks/bookmark_model.h"
 
 #include "app/l10n_util.h"
 #include "app/l10n_util_collator.h"
 #include "base/callback.h"
 #include "base/scoped_vector.h"
@@ skipping 276 matching lines @@
     return;
   }
 
   if (url == node->GetURL())
     return;
 
   AsMutable(node)->InvalidateFavicon();
   CancelPendingFavIconLoadRequests(AsMutable(node));
 
   {
-    AutoLock url_lock(url_lock_);
+    base::AutoLock url_lock(url_lock_);
     NodesOrderedByURLSet::iterator i = nodes_ordered_by_url_set_.find(
         AsMutable(node));
     DCHECK(i != nodes_ordered_by_url_set_.end());
     // i points to the first node with the URL, advance until we find the
     // node we're removing.
     while (*i != node)
       ++i;
     nodes_ordered_by_url_set_.erase(i);
 
     AsMutable(node)->SetURL(url);
     nodes_ordered_by_url_set_.insert(AsMutable(node));
   }
 
   if (store_.get())
     store_->ScheduleSave();
 
   FOR_EACH_OBSERVER(BookmarkModelObserver, observers_,
                     BookmarkNodeChanged(this, node));
 }
 
 bool BookmarkModel::IsLoaded() {
   return loaded_;
 }
 
 void BookmarkModel::GetNodesByURL(const GURL& url,
                                   std::vector<const BookmarkNode*>* nodes) {
-  AutoLock url_lock(url_lock_);
+  base::AutoLock url_lock(url_lock_);
   BookmarkNode tmp_node(url);
   NodesOrderedByURLSet::iterator i = nodes_ordered_by_url_set_.find(&tmp_node);
   while (i != nodes_ordered_by_url_set_.end() && (*i)->GetURL() == url) {
     nodes->push_back(*i);
     ++i;
   }
 }
 
 const BookmarkNode* BookmarkModel::GetMostRecentlyAddedNodeForURL(
     const GURL& url) {
   std::vector<const BookmarkNode*> nodes;
   GetNodesByURL(url, &nodes);
   if (nodes.empty())
     return NULL;
 
   std::sort(nodes.begin(), nodes.end(), &bookmark_utils::MoreRecentlyAdded);
   return nodes.front();
 }
 
 void BookmarkModel::GetBookmarks(std::vector<GURL>* urls) {
-  AutoLock url_lock(url_lock_);
+  base::AutoLock url_lock(url_lock_);
   const GURL* last_url = NULL;
   for (NodesOrderedByURLSet::iterator i = nodes_ordered_by_url_set_.begin();
        i != nodes_ordered_by_url_set_.end(); ++i) {
     const GURL* url = &((*i)->GetURL());
     // Only add unique URLs.
     if (!last_url || *url != *last_url)
       urls->push_back(*url);
     last_url = url;
   }
 }
 
 bool BookmarkModel::HasBookmarks() {
-  AutoLock url_lock(url_lock_);
+  base::AutoLock url_lock(url_lock_);
   return !nodes_ordered_by_url_set_.empty();
 }
 
 bool BookmarkModel::IsBookmarked(const GURL& url) {
-  AutoLock url_lock(url_lock_);
+  base::AutoLock url_lock(url_lock_);
   return IsBookmarkedNoLock(url);
 }
 
 const BookmarkNode* BookmarkModel::GetNodeByID(int64 id) {
   // TODO(sky): TreeNode needs a method that visits all nodes using a predicate.
   return GetNodeByID(&root_, id);
 }
 
 const BookmarkNode* BookmarkModel::AddGroup(const BookmarkNode* parent,
                                             int index,
@@ skipping 36 matching lines @@
 
   SetDateGroupModified(parent, creation_time);
 
   BookmarkNode* new_node = new BookmarkNode(generate_next_node_id(), url);
   new_node->SetTitle(title);
   new_node->set_date_added(creation_time);
   new_node->set_type(BookmarkNode::URL);
 
   {
     // Only hold the lock for the duration of the insert.
-    AutoLock url_lock(url_lock_);
+    base::AutoLock url_lock(url_lock_);
     nodes_ordered_by_url_set_.insert(new_node);
   }
 
   return AddNode(AsMutable(parent), index, new_node, was_bookmarked);
 }
 
 void BookmarkModel::SortChildren(const BookmarkNode* parent) {
   if (!parent || !parent->is_folder() || is_root(parent) ||
       parent->GetChildCount() <= 1) {
     return;
@@ skipping 134 matching lines @@
   bookmark_bar_node_ = details->release_bb_node();
   other_node_ = details->release_other_folder_node();
   index_.reset(details->release_index());
 
   // WARNING: order is important here, various places assume bookmark bar then
   // other node.
   root_.Add(0, bookmark_bar_node_);
   root_.Add(1, other_node_);
 
   {
-    AutoLock url_lock(url_lock_);
+    base::AutoLock url_lock(url_lock_);
     // Update nodes_ordered_by_url_set_ from the nodes.
     PopulateNodesByURL(&root_);
   }
 
   loaded_ = true;
 
   loaded_signal_.Signal();
 
   // Notify our direct observers.
   FOR_EACH_OBSERVER(BookmarkModelObserver, observers_, Loaded(this));
 
   // And generic notification.
   NotificationService::current()->Notify(
       NotificationType::BOOKMARK_MODEL_LOADED,
       Source<Profile>(profile_),
       NotificationService::NoDetails());
 }
 
 void BookmarkModel::RemoveAndDeleteNode(BookmarkNode* delete_me) {
   scoped_ptr<BookmarkNode> node(delete_me);
 
   BookmarkNode* parent = AsMutable(node->GetParent());
   DCHECK(parent);
   int index = parent->IndexOfChild(node.get());
   parent->Remove(index);
   history::URLsStarredDetails details(false);
   {
-    AutoLock url_lock(url_lock_);
+    base::AutoLock url_lock(url_lock_);
     RemoveNode(node.get(), &details.changed_urls);
 
     // RemoveNode adds an entry to changed_urls for each node of type URL. As we
     // allow duplicates we need to remove any entries that are still bookmarked.
     for (std::set<GURL>::iterator i = details.changed_urls.begin();
          i != details.changed_urls.end(); ) {
       if (IsBookmarkedNoLock(*i)) {
         // When we erase the iterator pointing at the erasee is
         // invalidated, so using i++ here within the "erase" call is
         // important as it advances the iterator before passing the
@@ skipping 206 matching lines @@
 void BookmarkModel::SetFileChanged() {
   file_changed_ = true;
 }
 
 BookmarkLoadDetails* BookmarkModel::CreateLoadDetails() {
   BookmarkNode* bb_node = CreateBookmarkNode();
   BookmarkNode* other_folder_node = CreateOtherBookmarksNode();
   return new BookmarkLoadDetails(
       bb_node, other_folder_node, new BookmarkIndex(profile()), next_node_id_);
 }