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

printing/printed_document.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 "printing/printed_document.h"
 
 #include <algorithm>
 #include <set>
 #include <string>
 #include <vector>
@@ skipping 60 matching lines @@
                               bool has_visible_overlays) {
   // Notice the page_number + 1, the reason is that this is the value that will
   // be shown. Users dislike 0-based counting.
   scoped_refptr<PrintedPage> page(
       new PrintedPage(page_number + 1,
                       metafile,
                       paper_size,
                       page_rect,
                       has_visible_overlays));
   {
-    AutoLock lock(lock_);
+    base::AutoLock lock(lock_);
     mutable_.pages_[page_number] = page;
     if (mutable_.shrink_factor == 0) {
       mutable_.shrink_factor = shrink;
     } else {
       DCHECK_EQ(mutable_.shrink_factor, shrink);
     }
   }
   DebugDump(*page);
 }
 
 bool PrintedDocument::GetPage(int page_number,
                               scoped_refptr<PrintedPage>* page) {
-  AutoLock lock(lock_);
+  base::AutoLock lock(lock_);
   PrintedPages::const_iterator itr = mutable_.pages_.find(page_number);
   if (itr != mutable_.pages_.end()) {
     if (itr->second.get()) {
       *page = itr->second;
       return true;
     }
   }
   return false;
 }
 
 bool PrintedDocument::IsComplete() const {
-  AutoLock lock(lock_);
+  base::AutoLock lock(lock_);
   if (!mutable_.page_count_)
     return false;
   PageNumber page(immutable_.settings_, mutable_.page_count_);
   if (page == PageNumber::npos())
     return false;
   for (; page != PageNumber::npos(); ++page) {
     PrintedPages::const_iterator itr = mutable_.pages_.find(page.ToInt());
     if (itr == mutable_.pages_.end() || !itr->second.get() ||
         !itr->second->native_metafile())
       return false;
   }
   return true;
 }
 
 void PrintedDocument::DisconnectSource() {
-  AutoLock lock(lock_);
+  base::AutoLock lock(lock_);
   mutable_.source_ = NULL;
 }
 
 uint32 PrintedDocument::MemoryUsage() const {
   std::vector< scoped_refptr<PrintedPage> > pages_copy;
   {
-    AutoLock lock(lock_);
+    base::AutoLock lock(lock_);
     pages_copy.reserve(mutable_.pages_.size());
     PrintedPages::const_iterator end = mutable_.pages_.end();
     for (PrintedPages::const_iterator itr = mutable_.pages_.begin();
          itr != end; ++itr) {
       if (itr->second.get()) {
         pages_copy.push_back(itr->second);
       }
     }
   }
   uint32 total = 0;
   for (size_t i = 0; i < pages_copy.size(); ++i) {
     total += pages_copy[i]->native_metafile()->GetDataSize();
   }
   return total;
 }
 
 void PrintedDocument::set_page_count(int max_page) {
-  AutoLock lock(lock_);
+  base::AutoLock lock(lock_);
   DCHECK_EQ(0, mutable_.page_count_);
   mutable_.page_count_ = max_page;
   if (immutable_.settings_.ranges.empty()) {
     mutable_.expected_page_count_ = max_page;
   } else {
     // If there is a range, don't bother since expected_page_count_ is already
     // initialized.
     DCHECK_NE(mutable_.expected_page_count_, 0);
   }
 }
 
 int PrintedDocument::page_count() const {
-  AutoLock lock(lock_);
+  base::AutoLock lock(lock_);
   return mutable_.page_count_;
 }
 
 int PrintedDocument::expected_page_count() const {
-  AutoLock lock(lock_);
+  base::AutoLock lock(lock_);
   return mutable_.expected_page_count_;
 }
 
 void PrintedDocument::PrintHeaderFooter(gfx::NativeDrawingContext context,
                                         const PrintedPage& page,
                                         PageOverlays::HorizontalPosition x,
                                         PageOverlays::VerticalPosition y,
                                         const gfx::Font& font) const {
   const PrintSettings& settings = immutable_.settings_;
   if (!settings.use_overlays || !page.has_visible_overlays()) {
@@ skipping 108 matching lines @@
       name_(source->RenderSourceName()),
       url_(source->RenderSourceUrl()),
       cookie_(cookie) {
   SetDocumentDate();
 }
 
 PrintedDocument::Immutable::~Immutable() {
 }
 
 }  // namespace printing