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

app/resource_bundle_linux.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 "app/resource_bundle.h"
 
 #include <gtk/gtk.h>
 
 #include "app/app_paths.h"
 #include "base/base_paths.h"
 #include "base/file_path.h"
 #include "base/file_util.h"
 #include "base/i18n/rtl.h"
-#include "base/lock.h"
 #include "base/logging.h"
 #include "base/path_service.h"
 #include "base/string_piece.h"
 #include "base/string_util.h"
+#include "base/synchronization/lock.h"
 #include "gfx/font.h"
 #include "gfx/gtk_util.h"
 #include "third_party/skia/include/core/SkBitmap.h"
 
 namespace {
 
 // Convert the raw image data into a GdkPixbuf.  The GdkPixbuf that is returned
 // has a ref count of 1 so the caller must call g_object_unref to free the
 // memory.
 GdkPixbuf* LoadPixbuf(RefCountedStaticMemory* data, bool rtl_enabled) {
@@ skipping 54 matching lines @@
     return FilePath();
   return locale_file_path;
 }
 
 GdkPixbuf* ResourceBundle::GetPixbufImpl(int resource_id, bool rtl_enabled) {
   // Use the negative |resource_id| for the key for BIDI-aware images.
   int key = rtl_enabled ? -resource_id : resource_id;
 
   // Check to see if we already have the pixbuf in the cache.
   {
-    AutoLock lock_scope(*lock_);
+    base::AutoLock lock_scope(*lock_);
     GdkPixbufMap::const_iterator found = gdk_pixbufs_.find(key);
     if (found != gdk_pixbufs_.end())
       return found->second;
   }
 
   scoped_refptr<RefCountedStaticMemory> data(
       LoadDataResourceBytes(resource_id));
   GdkPixbuf* pixbuf = LoadPixbuf(data.get(), rtl_enabled);
 
   // We loaded successfully.  Cache the pixbuf.
   if (pixbuf) {
-    AutoLock lock_scope(*lock_);
+    base::AutoLock lock_scope(*lock_);
 
     // Another thread raced us, and has already cached the pixbuf.
     if (gdk_pixbufs_.count(key)) {
       g_object_unref(pixbuf);
       return gdk_pixbufs_[key];
     }
 
     gdk_pixbufs_[key] = pixbuf;
     return pixbuf;
   }
 
   // We failed to retrieve the bitmap, show a debugging red square.
   {
     LOG(WARNING) << "Unable to load GdkPixbuf with id " << resource_id;
     NOTREACHED();  // Want to assert in debug mode.
 
-    AutoLock lock_scope(*lock_);  // Guard empty_bitmap initialization.
+    base::AutoLock lock_scope(*lock_);  // Guard empty_bitmap initialization.
 
     static GdkPixbuf* empty_bitmap = NULL;
     if (!empty_bitmap) {
       // The placeholder bitmap is bright red so people notice the problem.
       // This bitmap will be leaked, but this code should never be hit.
       scoped_ptr<SkBitmap> skia_bitmap(new SkBitmap());
       skia_bitmap->setConfig(SkBitmap::kARGB_8888_Config, 32, 32);
       skia_bitmap->allocPixels();
       skia_bitmap->eraseARGB(255, 255, 0, 0);
       empty_bitmap = gfx::GdkPixbufFromSkBitmap(skia_bitmap.get());
     }
     return empty_bitmap;
   }
 }
 
 GdkPixbuf* ResourceBundle::GetPixbufNamed(int resource_id) {
   return GetPixbufImpl(resource_id, false);
 }
 
 GdkPixbuf* ResourceBundle::GetRTLEnabledPixbufNamed(int resource_id) {
   return GetPixbufImpl(resource_id, true);
 }