Move FilePathWatcher class from browser/... to common/...

content/common/file_path_watcher/file_path_watcher.h

 // 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.
 
 // This module provides a way to monitor a file or directory for changes.
 
-#ifndef CHROME_BROWSER_FILE_PATH_WATCHER_FILE_PATH_WATCHER_H_
-#define CHROME_BROWSER_FILE_PATH_WATCHER_FILE_PATH_WATCHER_H_
+#ifndef CONTENT_COMMON_FILE_PATH_WATCHER_FILE_PATH_WATCHER_H_
+#define CONTENT_COMMON_FILE_PATH_WATCHER_FILE_PATH_WATCHER_H_
 #pragma once
 
 #include "base/basictypes.h"
 #include "base/file_path.h"
+#include "base/message_loop_proxy.h"
 #include "base/ref_counted.h"
-#include "content/browser/browser_thread.h"
 
 // This class lets you register interest in changes on a FilePath.
 // The delegate will get called whenever the file or directory referenced by the
 // FilePath is changed, including created or deleted. Due to limitations in the
 // underlying OS APIs, spurious notifications might occur that don't relate to
 // an actual change to the watch target.
 class FilePathWatcher {
  public:
   // Declares the callback client code implements to receive notifications. Note
   // that implementations of this interface should not keep a reference to the
   // corresponding FileWatcher object to prevent a reference cycle.
   class Delegate : public base::RefCountedThreadSafe<Delegate> {
    public:
     virtual ~Delegate() {}
     virtual void OnFilePathChanged(const FilePath& path) = 0;
     // Called when platform specific code detected an error. The watcher will
     // not call OnFilePathChanged for future changes.
     virtual void OnError() {}
   };
 
   FilePathWatcher();
   ~FilePathWatcher();
 
   // Register interest in any changes on |path|. OnPathChanged will be called
-  // back for each change. Returns true on success.
-  bool Watch(const FilePath& path, Delegate* delegate) WARN_UNUSED_RESULT;
+  // back for each change. Returns true on success. |loop| is only used
+  // by the Mac implementation right now, and must be backed by a CFRunLoop
+  // based MessagePump. This is usually going to be a MessageLoop of type
+  // TYPE_UI.
+  bool Watch(const FilePath& path,
+             Delegate* delegate,
+             scoped_refptr<base::MessageLoopProxy> loop) WARN_UNUSED_RESULT;

[Mattias Nissler (ping if slow), 2011/03/17 18:14:27]

Plain pointer here, too?

+
+  class PlatformDelegate;
+
+  // Traits for PlatformDelegate, which must delete itself on the IO message
+  // loop that Watch was called from.
+  struct DeletePlatformDelegate {
+    static void Destruct(const PlatformDelegate* delegate);
+  };
 
   // Used internally to encapsulate different members on different platforms.
   class PlatformDelegate
       : public base::RefCountedThreadSafe<PlatformDelegate,
-                                          BrowserThread::DeleteOnFileThread> {
+                                          DeletePlatformDelegate> {
    public:
     // Start watching for the given |path| and notify |delegate| about changes.
-    virtual bool Watch(const FilePath& path, Delegate* delegate)
-        WARN_UNUSED_RESULT = 0;
+    // |loop| is only used by the Mac implementation right now, and must be
+    // backed by a CFRunLoop based MessagePump. This is usually going to be a
+    // MessageLoop of type TYPE_UI.
+    virtual bool Watch(
+        const FilePath& path,
+        Delegate* delegate,
+        scoped_refptr<base::MessageLoopProxy> loop) WARN_UNUSED_RESULT = 0;

[Mattias Nissler (ping if slow), 2011/03/17 18:14:27]

and here?

 
     // Stop watching. This is called from FilePathWatcher's dtor in order to
     // allow to shut down properly while the object is still alive.
-    virtual void Cancel() {}
+    virtual void Cancel() = 0;
+
+    scoped_refptr<base::MessageLoopProxy> message_loop() const {

[Mattias Nissler (ping if slow), 2011/03/17 18:14:27]

Why is this public? The only reason I can see is that the inotify implementation
can fetch the message loop and post something on the watcher impl object (this
could be easily resolved by moving the thread switch into the impl class, where
it belongs).

+      return message_loop_;
+    }
+    void set_message_loop(scoped_refptr<base::MessageLoopProxy> loop);

[Mattias Nissler (ping if slow), 2011/03/17 18:14:27]

It seems odd that the message_loop_ accessors are public. Moreover, why do you
pass in one of the message loops in Watch() and install the other at the same
time in set_message_loop()?

 
    protected:
-    friend struct BrowserThread::DeleteOnThread<BrowserThread::FILE>;
     friend class DeleteTask<PlatformDelegate>;
+    friend struct DeletePlatformDelegate;
+    virtual ~PlatformDelegate();
 
-    virtual ~PlatformDelegate() {}
+   private:
+    // IO Message Loop.
+    scoped_refptr<base::MessageLoopProxy> message_loop_;
   };
 
  private:
   scoped_refptr<PlatformDelegate> impl_;
 
   DISALLOW_COPY_AND_ASSIGN(FilePathWatcher);
 };
 
-#endif  // CHROME_BROWSER_FILE_PATH_WATCHER_FILE_PATH_WATCHER_H_
+#endif  // CONTENT_COMMON_FILE_PATH_WATCHER_FILE_PATH_WATCHER_H_