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

ipc/ipc_channel_posix.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 "ipc/ipc_channel_posix.h"
 
 #include <errno.h>
 #include <fcntl.h>
 #include <stddef.h>
 #include <sys/types.h>
 #include <sys/socket.h>
 #include <sys/stat.h>
 #include <sys/un.h>
 
 #include <string>
 #include <map>
 
 #include "base/command_line.h"
 #include "base/eintr_wrapper.h"
 #include "base/file_path.h"
 #include "base/file_util.h"
 #include "base/global_descriptors_posix.h"
-#include "base/lock.h"
 #include "base/logging.h"
 #include "base/process_util.h"
 #include "base/scoped_ptr.h"
 #include "base/singleton.h"
 #include "base/string_util.h"
+#include "base/synchronization/lock.h"
 #include "ipc/ipc_descriptors.h"
 #include "ipc/ipc_switches.h"
 #include "ipc/file_descriptor_set_posix.h"
 #include "ipc/ipc_logging.h"
 #include "ipc/ipc_message_utils.h"
 
 namespace IPC {
 
 // IPC channels on Windows use named pipes (CreateNamedPipe()) with
 // channel ids as the pipe names.  Channels on POSIX use sockets as
@@ skipping 45 matching lines @@
     return Singleton<PipeMap>::get();
   }
 
   ~PipeMap() {
     // Shouldn't have left over pipes.
     DCHECK(map_.size() == 0);
   }
 
   // Lookup a given channel id. Return -1 if not found.
   int Lookup(const std::string& channel_id) {
-    AutoLock locked(lock_);
+    base::AutoLock locked(lock_);
 
     ChannelToFDMap::const_iterator i = map_.find(channel_id);
     if (i == map_.end())
       return -1;
     return i->second;
   }
 
   // Remove the mapping for the given channel id. No error is signaled if the
   // channel_id doesn't exist
   void RemoveAndClose(const std::string& channel_id) {
-    AutoLock locked(lock_);
+    base::AutoLock locked(lock_);
 
     ChannelToFDMap::iterator i = map_.find(channel_id);
     if (i != map_.end()) {
       if (HANDLE_EINTR(close(i->second)) < 0)
         PLOG(ERROR) << "close " << channel_id;
       map_.erase(i);
     }
   }
 
   // Insert a mapping from @channel_id to @fd. It's a fatal error to insert a
   // mapping if one already exists for the given channel_id
   void Insert(const std::string& channel_id, int fd) {
-    AutoLock locked(lock_);
+    base::AutoLock locked(lock_);
     DCHECK(fd != -1);
 
     ChannelToFDMap::const_iterator i = map_.find(channel_id);
     CHECK(i == map_.end()) << "Creating second IPC server (fd " << fd << ") "
                            << "for '" << channel_id << "' while first "
                            << "(fd " << i->second << ") still exists";
     map_[channel_id] = fd;
   }
 
  private:
-  Lock lock_;
+  base::Lock lock_;
   typedef std::map<std::string, int> ChannelToFDMap;
   ChannelToFDMap map_;
 
   friend struct DefaultSingletonTraits<PipeMap>;
 };
 
 //------------------------------------------------------------------------------
 // Verify that kMaxPipeNameLength is a decent size.
 COMPILE_ASSERT(sizeof(((sockaddr_un*)0)->sun_path) >= kMaxPipeNameLength,
                BAD_SUN_PATH_LENGTH);
@@ skipping 1009 matching lines @@
 
 bool Channel::HasAcceptedConnection() const {
   return channel_impl_->HasAcceptedConnection();
 }
 
 void Channel::ResetToAcceptingConnectionState() {
   channel_impl_->ResetToAcceptingConnectionState();
 }
 
 }  // namespace IPC