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

chrome/browser/file_path_watcher/file_path_watcher_inotify.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/file_path_watcher/file_path_watcher.h"
 
 #include <errno.h>
 #include <string.h>
 #include <sys/inotify.h>
 #include <sys/ioctl.h>
 #include <sys/select.h>
 #include <unistd.h>
 
 #include <algorithm>
 #include <set>
 #include <utility>
 #include <vector>
 
 #include "base/eintr_wrapper.h"
 #include "base/file_path.h"
 #include "base/file_util.h"
 #include "base/hash_tables.h"
 #include "base/lazy_instance.h"
-#include "base/lock.h"
 #include "base/logging.h"
 #include "base/message_loop.h"
 #include "base/scoped_ptr.h"
+#include "base/synchronization/lock.h"
 #include "base/task.h"
 #include "base/threading/thread.h"
 
 namespace {
 
 class FilePathWatcherImpl;
 
 // Singleton to manage all inotify watches.
 // TODO(tony): It would be nice if this wasn't a singleton.
 // http://crbug.com/38174
@@ skipping 17 matching lines @@
 
   typedef std::set<FilePathWatcherImpl*> WatcherSet;
 
   InotifyReader();
   ~InotifyReader();
 
   // We keep track of which delegates want to be notified on which watches.
   base::hash_map<Watch, WatcherSet> watchers_;
 
   // Lock to protect watchers_.
-  Lock lock_;
+  base::Lock lock_;
 
   // Separate thread on which we run blocking read for inotify events.
   base::Thread thread_;
 
   // File descriptor returned by inotify_init.
   const int inotify_fd_;
 
   // Use self-pipe trick to unblock select during shutdown.
   int shutdown_pipe_[2];
 
@@ skipping 154 matching lines @@
     close(shutdown_pipe_[0]);
   if (shutdown_pipe_[1] >= 0)
     close(shutdown_pipe_[1]);
 }
 
 InotifyReader::Watch InotifyReader::AddWatch(
     const FilePath& path, FilePathWatcherImpl* watcher) {
   if (!valid_)
     return kInvalidWatch;
 
-  AutoLock auto_lock(lock_);
+  base::AutoLock auto_lock(lock_);
 
   Watch watch = inotify_add_watch(inotify_fd_, path.value().c_str(),
                                   IN_CREATE | IN_DELETE |
                                   IN_CLOSE_WRITE | IN_MOVE |
                                   IN_ONLYDIR);
 
   if (watch == kInvalidWatch)
     return kInvalidWatch;
 
   watchers_[watch].insert(watcher);
 
   return watch;
 }
 
 bool InotifyReader::RemoveWatch(Watch watch,
                                 FilePathWatcherImpl* watcher) {
   if (!valid_)
     return false;
 
-  AutoLock auto_lock(lock_);
+  base::AutoLock auto_lock(lock_);
 
   watchers_[watch].erase(watcher);
 
   if (watchers_[watch].empty()) {
     watchers_.erase(watch);
     return (inotify_rm_watch(inotify_fd_, watch) == 0);
   }
 
   return true;
 }
 
 void InotifyReader::OnInotifyEvent(const inotify_event* event) {
   if (event->mask & IN_IGNORED)
     return;
 
   FilePath::StringType child(event->len ? event->name : FILE_PATH_LITERAL(""));
-  AutoLock auto_lock(lock_);
+  base::AutoLock auto_lock(lock_);
 
   for (WatcherSet::iterator watcher = watchers_[event->wd].begin();
        watcher != watchers_[event->wd].end();
        ++watcher) {
     BrowserThread::PostTask(BrowserThread::FILE, FROM_HERE,
         NewRunnableMethod(*watcher,
                           &FilePathWatcherImpl::OnFilePathChanged,
                           event->wd,
                           child,
                           event->mask & (IN_CREATE | IN_MOVED_TO),
@@ skipping 115 matching lines @@
   }
 
   return true;
 }
 
 }  // namespace
 
 FilePathWatcher::FilePathWatcher() {
   impl_ = new FilePathWatcherImpl();
 }