chrome/browser/chromeos/drive/file_write_watcher.cc

   1 // Copyright 2013 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "chrome/browser/chromeos/drive/file_write_watcher.h"
   6
   7 #include <map>
   8 #include <vector>
   9
  10 #include "base/bind.h"
  11 #include "base/callback.h"
  12 #include "base/files/file_path_watcher.h"
  13 #include "base/stl_util.h"
  14 #include "base/timer/timer.h"
  15 #include "google_apis/drive/task_util.h"
  16
  17 namespace drive {
  18 namespace internal {
  19
  20 namespace {
  21 const int64 kWriteEventDelayInSeconds = 5;
  22 }  // namespace
  23
  24 // base::FileWatcher needs to live in a thread that is allowed to do File IO
  25 // and has a TYPE_IO message loop: that is, FILE thread. This class bridges the
  26 // UI thread and FILE thread, and does all the main tasks in the FILE thread.
  27 class FileWriteWatcher::FileWriteWatcherImpl {
  28  public:
  29   explicit FileWriteWatcherImpl(base::SingleThreadTaskRunner* file_task_runner);
  30
  31   // Forwards the call to DestoryOnFileThread(). This method must be used to
  32   // destruct the instance.
  33   void Destroy();
  34
  35   // Forwards the call to StartWatchOnFileThread(). |on_start_callback| is
  36   // called back on the caller (UI) thread when the watch has started.
  37   // |on_write_callback| is called when a write has happened to the path.
  38   void StartWatch(const base::FilePath& path,
  39                   const StartWatchCallback& on_start_callback,
  40                   const base::Closure& on_write_callback);
  41
  42   void set_delay(base::TimeDelta delay) { delay_ = delay; }
  43
  44  private:
  45   ~FileWriteWatcherImpl();
  46
  47   void DestroyOnFileThread();
  48
  49   void StartWatchOnFileThread(const base::FilePath& path,
  50                               const StartWatchCallback& on_start_callback,
  51                               const base::Closure& on_write_callback);
  52
  53   void OnWriteEvent(const base::FilePath& path, bool error);
  54
  55   void InvokeCallback(const base::FilePath& path);
  56
  57   struct PathWatchInfo {
  58     std::vector<base::Closure> on_write_callbacks;
  59     base::FilePathWatcher watcher;
  60     base::Timer timer;
  61
  62     explicit PathWatchInfo(const base::Closure& on_write_callback)
  63         : on_write_callbacks(1, on_write_callback),
  64           timer(false /* retain_closure_on_reset */, false /* is_repeating */) {
  65     }
  66   };
  67
  68   base::TimeDelta delay_;
  69   std::map<base::FilePath, PathWatchInfo*> watchers_;
  70   scoped_refptr<base::SingleThreadTaskRunner> file_task_runner_;
  71
  72   base::ThreadChecker thread_checker_;
  73
  74   // Note: This should remain the last member so it'll be destroyed and
  75   // invalidate its weak pointers before any other members are destroyed.
  76   base::WeakPtrFactory<FileWriteWatcherImpl> weak_ptr_factory_;
  77   DISALLOW_COPY_AND_ASSIGN(FileWriteWatcherImpl);
  78 };
  79
  80 FileWriteWatcher::FileWriteWatcherImpl::FileWriteWatcherImpl(
  81     base::SingleThreadTaskRunner* file_task_runner)
  82     : delay_(base::TimeDelta::FromSeconds(kWriteEventDelayInSeconds)),
  83       file_task_runner_(file_task_runner),
  84       weak_ptr_factory_(this) {
  85 }
  86
  87 void FileWriteWatcher::FileWriteWatcherImpl::Destroy() {
  88   DCHECK(thread_checker_.CalledOnValidThread());
  89
  90   // Just forwarding the call to FILE thread.
  91   file_task_runner_->PostTask(
  92       FROM_HERE, base::Bind(&FileWriteWatcherImpl::DestroyOnFileThread,
  93                             base::Unretained(this)));
  94 }
  95
  96 void FileWriteWatcher::FileWriteWatcherImpl::StartWatch(
  97     const base::FilePath& path,
  98     const StartWatchCallback& on_start_callback,
  99     const base::Closure& on_write_callback) {
 100   DCHECK(thread_checker_.CalledOnValidThread());
 101
 102   // Forwarding the call to FILE thread and relaying the |callback|.
 103   file_task_runner_->PostTask(
 104       FROM_HERE,
 105       base::Bind(&FileWriteWatcherImpl::StartWatchOnFileThread,
 106                  base::Unretained(this), path,
 107                  google_apis::CreateRelayCallback(on_start_callback),
 108                  google_apis::CreateRelayCallback(on_write_callback)));
 109 }
 110
 111 FileWriteWatcher::FileWriteWatcherImpl::~FileWriteWatcherImpl() {
 112   DCHECK(file_task_runner_->BelongsToCurrentThread());
 113
 114   STLDeleteContainerPairSecondPointers(watchers_.begin(), watchers_.end());
 115 }
 116
 117 void FileWriteWatcher::FileWriteWatcherImpl::DestroyOnFileThread() {
 118   DCHECK(file_task_runner_->BelongsToCurrentThread());
 119
 120   delete this;
 121 }
 122
 123 void FileWriteWatcher::FileWriteWatcherImpl::StartWatchOnFileThread(
 124     const base::FilePath& path,
 125     const StartWatchCallback& on_start_callback,
 126     const base::Closure& on_write_callback) {
 127   DCHECK(file_task_runner_->BelongsToCurrentThread());
 128
 129   std::map<base::FilePath, PathWatchInfo*>::iterator it = watchers_.find(path);
 130   if (it != watchers_.end()) {
 131     // We are already watching the path.
 132     on_start_callback.Run(true);
 133     it->second->on_write_callbacks.push_back(on_write_callback);
 134     return;
 135   }
 136
 137   // Start watching |path|.
 138   scoped_ptr<PathWatchInfo> info(new PathWatchInfo(on_write_callback));
 139   bool ok = info->watcher.Watch(
 140       path,
 141       false,  // recursive
 142       base::Bind(&FileWriteWatcherImpl::OnWriteEvent,
 143                  weak_ptr_factory_.GetWeakPtr()));
 144   watchers_[path] = info.release();
 145   on_start_callback.Run(ok);
 146 }
 147
 148 void FileWriteWatcher::FileWriteWatcherImpl::OnWriteEvent(
 149     const base::FilePath& path,
 150     bool error) {
 151   DCHECK(file_task_runner_->BelongsToCurrentThread());
 152
 153   if (error)
 154     return;
 155
 156   std::map<base::FilePath, PathWatchInfo*>::iterator it = watchers_.find(path);
 157   DCHECK(it != watchers_.end());
 158
 159   // Heuristics for detecting the end of successive write operations.
 160   // Delay running on_write_event_callback by |delay_| time, and if OnWriteEvent
 161   // is called again in the period, the timer is reset. In other words, we
 162   // invoke callback when |delay_| has passed after the last OnWriteEvent().
 163   it->second->timer.Start(FROM_HERE,
 164                           delay_,
 165                           base::Bind(&FileWriteWatcherImpl::InvokeCallback,
 166                                      weak_ptr_factory_.GetWeakPtr(),
 167                                      path));
 168 }
 169
 170 void FileWriteWatcher::FileWriteWatcherImpl::InvokeCallback(
 171     const base::FilePath& path) {
 172   DCHECK(file_task_runner_->BelongsToCurrentThread());
 173
 174   std::map<base::FilePath, PathWatchInfo*>::iterator it = watchers_.find(path);
 175   DCHECK(it != watchers_.end());
 176
 177   std::vector<base::Closure> callbacks;
 178   callbacks.swap(it->second->on_write_callbacks);
 179   delete it->second;
 180   watchers_.erase(it);
 181
 182   for (size_t i = 0; i < callbacks.size(); ++i)
 183     callbacks[i].Run();
 184 }
 185
 186 FileWriteWatcher::FileWriteWatcher(
 187     base::SingleThreadTaskRunner* file_task_runner)
 188     : watcher_impl_(new FileWriteWatcherImpl(file_task_runner)) {
 189 }
 190
 191 FileWriteWatcher::~FileWriteWatcher() {
 192   DCHECK(thread_checker_.CalledOnValidThread());
 193 }
 194
 195 void FileWriteWatcher::StartWatch(const base::FilePath& file_path,
 196                                   const StartWatchCallback& on_start_callback,
 197                                   const base::Closure& on_write_callback) {
 198   DCHECK(thread_checker_.CalledOnValidThread());
 199   watcher_impl_->StartWatch(file_path, on_start_callback, on_write_callback);
 200 }
 201
 202 void FileWriteWatcher::DisableDelayForTesting() {
 203   watcher_impl_->set_delay(base::TimeDelta());
 204 }
 205
 206 }  // namespace internal
 207 }  // namespace drive