Move FilePathWatcher to base/files.

base/files/file_path_watcher_mac.cc

 // Copyright (c) 2011 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 "content/common/file_path_watcher/file_path_watcher.h"
+#include "base/files/file_path_watcher.h"
 
 #include <fcntl.h>
 #include <sys/event.h>
 #include <sys/param.h>
 
 #include <vector>
 
 #include "base/file_util.h"
 #include "base/message_loop.h"
 #include "base/message_loop_proxy.h"
@@ skipping 14 matching lines @@
 // send notifications. See
 // http://code.google.com/p/chromium/issues/detail?id=54822#c31 for source that
 // will reproduce the problem. FSEvents also required having a CFRunLoop
 // backing the thread that it was running on, that caused added complexity
 // in the interfaces.
 // The kqueue implementation will handle all of the items in the list above
 // except for detecting modifications to files in a watched directory. It will
 // detect the creation and deletion of files, just not the modification of
 // files. It does however detect the attribute changes that the FSEvents impl
 // would miss.
-class FilePathWatcherImpl : public FilePathWatcher::PlatformDelegate,
-                            public MessageLoopForIO::Watcher,
-                            public MessageLoop::DestructionObserver {
+class FilePathWatcherImpl
+    : public base::files::FilePathWatcher::PlatformDelegate,
+      public MessageLoopForIO::Watcher,
+      public MessageLoop::DestructionObserver {
  public:
   FilePathWatcherImpl() : kqueue_(-1) {}
   virtual ~FilePathWatcherImpl() {}
 
   // MessageLoopForIO::Watcher overrides.
   virtual void OnFileCanReadWithoutBlocking(int fd) OVERRIDE;
   virtual void OnFileCanWriteWithoutBlocking(int fd) OVERRIDE;
 
   // MessageLoop::DestructionObserver overrides.
   virtual void WillDestroyCurrentMessageLoop() OVERRIDE;
 
   // FilePathWatcher::PlatformDelegate overrides.
   virtual bool Watch(const FilePath& path,
-                     FilePathWatcher::Delegate* delegate) OVERRIDE;
+                     base::files::FilePathWatcher::Delegate* delegate) OVERRIDE;
   virtual void Cancel() OVERRIDE;
 
  private:
   class EventData {
    public:
     EventData(const FilePath& path, const FilePath::StringType& subdir)
         : path_(path), subdir_(subdir) { }
     FilePath path_;  // Full path to this item.
     FilePath::StringType subdir_;  // Path to any sub item.
   };
@@ skipping 51 matching lines @@
     return event.ident != static_cast<uintptr_t>(-1);
   }
 
   static EventData* EventDataForKevent(const struct kevent& event) {
     return reinterpret_cast<EventData*>(event.udata);
   }
 
   EventVector events_;
   scoped_refptr<base::MessageLoopProxy> io_message_loop_;
   MessageLoopForIO::FileDescriptorWatcher kqueue_watcher_;
-  scoped_refptr<FilePathWatcher::Delegate> delegate_;
+  scoped_refptr<base::files::FilePathWatcher::Delegate> delegate_;
   FilePath target_;
   int kqueue_;
 
   DISALLOW_COPY_AND_ASSIGN(FilePathWatcherImpl);
 };
 
 void FilePathWatcherImpl::ReleaseEvent(struct kevent& event) {
   CloseFileDescriptor(reinterpret_cast<int*>(&event.ident));
   EventData* entry = EventDataForKevent(event);
   delete entry;
@@ skipping 267 matching lines @@
 }
 
 void FilePathWatcherImpl::OnFileCanWriteWithoutBlocking(int fd) {
   NOTREACHED();
 }
 
 void FilePathWatcherImpl::WillDestroyCurrentMessageLoop() {
   CancelOnMessageLoopThread();
 }
 
-bool FilePathWatcherImpl::Watch(const FilePath& path,
-                                FilePathWatcher::Delegate* delegate) {
+bool FilePathWatcherImpl::Watch(
+    const FilePath& path,
+    base::files::FilePathWatcher::Delegate* delegate) {
   DCHECK(MessageLoopForIO::current());
   DCHECK(target_.value().empty());  // Can only watch one path.
   DCHECK(delegate);
   DCHECK_EQ(kqueue_, -1);
 
   delegate_ = delegate;
   target_ = path;
 
   MessageLoop::current()->AddDestructionObserver(this);
   io_message_loop_ = base::MessageLoopProxy::CreateForCurrentThread();
@@ skipping 47 matching lines @@
     std::for_each(events_.begin(), events_.end(), ReleaseEvent);
     events_.clear();
     io_message_loop_ = NULL;
     MessageLoop::current()->RemoveDestructionObserver(this);
     delegate_ = NULL;
   }
 }
 
 }  // namespace
 
-FilePathWatcher::FilePathWatcher() {
+base::files::FilePathWatcher::FilePathWatcher() {
   impl_ = new FilePathWatcherImpl();
 }