[fsp] Implement storage::WatcherManager for FSP.

chrome/browser/chromeos/file_system_provider/provided_file_system.cc

 // Copyright 2014 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/chromeos/file_system_provider/provided_file_system.h"
 
 #include <vector>
 
 #include "base/debug/trace_event.h"
 #include "base/files/file.h"
@@ skipping 351 matching lines @@
 
   return base::Bind(
       &ProvidedFileSystem::Abort, weak_ptr_factory_.GetWeakPtr(), request_id);
 }
 
 ProvidedFileSystem::AbortCallback ProvidedFileSystem::AddWatcher(
     const GURL& origin,
     const base::FilePath& entry_path,
     bool recursive,
     bool persistent,
-    const storage::AsyncFileUtil::StatusCallback& callback) {
+    const storage::AsyncFileUtil::StatusCallback& callback,
+    const storage::WatcherManager::NotificationCallback&
+        notification_callback) {
   // TODO(mtomasz): Wrap the entire method body with an asynchronous queue to
   // avoid races.
-  if (persistent && !file_system_info_.supports_notify_tag()) {
-    OnAddWatcherCompleted(origin,
-                          entry_path,
+  if (persistent && (!file_system_info_.supports_notify_tag() ||
+                     !notification_callback.is_null())) {
+    OnAddWatcherCompleted(entry_path,
                           recursive,
-                          persistent,
+                          Subscriber(),
                           callback,
                           base::File::FILE_ERROR_INVALID_OPERATION);
     return AbortCallback();
   }
 
+  // Create a candidate subscriber. This could be done in OnAddWatcherCompleted,
+  // but base::Bind supports only up to 7 arguments.
+  Subscriber subscriber;
+  subscriber.origin = origin;
+  subscriber.persistent = persistent;
+  subscriber.notification_callback = notification_callback;
+
   const WatcherKey key(entry_path, recursive);
   const Watchers::const_iterator it = watchers_.find(key);
   if (it != watchers_.end()) {
     const bool exists =
         it->second.subscribers.find(origin) != it->second.subscribers.end();
     OnAddWatcherCompleted(
-        origin,
         entry_path,
         recursive,
-        persistent,
+        subscriber,
         callback,
         exists ? base::File::FILE_ERROR_EXISTS : base::File::FILE_OK);
     return AbortCallback();
   }
 
   const int request_id = request_manager_->CreateRequest(
       ADD_WATCHER,
       scoped_ptr<RequestManager::HandlerInterface>(new operations::AddWatcher(
           event_router_,
           file_system_info_,
           entry_path,
           recursive,
           base::Bind(&ProvidedFileSystem::OnAddWatcherCompleted,
                      weak_ptr_factory_.GetWeakPtr(),
-                     origin,
                      entry_path,
                      recursive,
-                     persistent,
+                     subscriber,
                      callback))));
 
   if (!request_id) {
-    OnAddWatcherCompleted(origin,
-                          entry_path,
+    OnAddWatcherCompleted(entry_path,
                           recursive,
-                          persistent,
+                          subscriber,
                           callback,
                           base::File::FILE_ERROR_SECURITY);
     return AbortCallback();
   }
 
   return base::Bind(
       &ProvidedFileSystem::Abort, weak_ptr_factory_.GetWeakPtr(), request_id);
 }
 
 void ProvidedFileSystem::RemoveWatcher(
@@ skipping 61 matching lines @@
 }
 
 void ProvidedFileSystem::RemoveObserver(ProvidedFileSystemObserver* observer) {
   DCHECK(observer);
   observers_.RemoveObserver(observer);
 }
 
 bool ProvidedFileSystem::Notify(
     const base::FilePath& entry_path,
     bool recursive,
-    ProvidedFileSystemObserver::ChangeType change_type,
+    storage::WatcherManager::ChangeType change_type,
     scoped_ptr<ProvidedFileSystemObserver::Changes> changes,
     const std::string& tag) {
   const WatcherKey key(entry_path, recursive);
-  const Watchers::iterator it = watchers_.find(key);
-  if (it == watchers_.end())
+  const auto& watcher_it = watchers_.find(key);
+  if (watcher_it == watchers_.end())
     return false;
 
   // The tag must be provided if and only if it's explicitly supported.
   if (file_system_info_.supports_notify_tag() == tag.empty())
     return false;
 
   // The object is owned by AutoUpdated, so the reference is valid as long as
   // callbacks created with AutoUpdater::CreateCallback().
   const ProvidedFileSystemObserver::Changes& changes_ref = *changes.get();
 
   scoped_refptr<AutoUpdater> auto_updater(
       new AutoUpdater(base::Bind(&ProvidedFileSystem::OnNotifyCompleted,
                                  weak_ptr_factory_.GetWeakPtr(),
                                  entry_path,
                                  recursive,
                                  change_type,
                                  base::Passed(&changes),
-                                 it->second.last_tag,
+                                 watcher_it->second.last_tag,
                                  tag)));
 
+  // Call all notification callbacks (if any).
+  for (const auto& subscriber_it : watcher_it->second.subscribers) {
+    const storage::WatcherManager::NotificationCallback& notification_callback =
+        subscriber_it.second.notification_callback;
+    if (!notification_callback.is_null())
+      notification_callback.Run(change_type);
+  }
+
+  // Notify all observers.
   FOR_EACH_OBSERVER(ProvidedFileSystemObserver,
                     observers_,
                     OnWatcherChanged(file_system_info_,
-                                     it->second,
+                                     watcher_it->second,
                                      change_type,
                                      changes_ref,
                                      auto_updater->CreateCallback()));
 
   return true;
 }
 
 base::WeakPtr<ProvidedFileSystemInterface> ProvidedFileSystem::GetWeakPtr() {
   return weak_ptr_factory_.GetWeakPtr();
 }
 
 void ProvidedFileSystem::Abort(
     int operation_request_id,
     const storage::AsyncFileUtil::StatusCallback& callback) {
   request_manager_->RejectRequest(operation_request_id,
                                   make_scoped_ptr(new RequestValue()),
                                   base::File::FILE_ERROR_ABORT);
   if (!request_manager_->CreateRequest(
           ABORT,
           scoped_ptr<RequestManager::HandlerInterface>(
               new operations::Abort(event_router_,
                                     file_system_info_,
                                     operation_request_id,
                                     callback)))) {
     callback.Run(base::File::FILE_ERROR_SECURITY);
   }
 }
 
 void ProvidedFileSystem::OnAddWatcherCompleted(
-    const GURL& origin,
     const base::FilePath& entry_path,
     bool recursive,
-    bool persistent,
+    const Subscriber& subscriber,
     const storage::AsyncFileUtil::StatusCallback& callback,
     base::File::Error result) {
   if (result != base::File::FILE_OK) {
     callback.Run(result);
     return;
   }
 
   const WatcherKey key(entry_path, recursive);
   const Watchers::iterator it = watchers_.find(key);
   if (it != watchers_.end()) {
     callback.Run(base::File::FILE_OK);
     return;
   }
 
+  // TODO(mtomasz): Add a queue to prevent races.
   Watcher* const watcher = &watchers_[key];
   watcher->entry_path = entry_path;
   watcher->recursive = recursive;
-  watcher->subscribers[origin].origin = origin;
-  watcher->subscribers[origin].persistent |= persistent;
+  watcher->subscribers[subscriber.origin] = subscriber;
 
   FOR_EACH_OBSERVER(ProvidedFileSystemObserver,
                     observers_,
                     OnWatcherListChanged(file_system_info_, watchers_));
 
   callback.Run(base::File::FILE_OK);
 }
 
 void ProvidedFileSystem::OnNotifyCompleted(
     const base::FilePath& entry_path,
     bool recursive,
-    ProvidedFileSystemObserver::ChangeType change_type,
+    storage::WatcherManager::ChangeType change_type,
     scoped_ptr<ProvidedFileSystemObserver::Changes> /* changes */,
     const std::string& last_tag,
     const std::string& tag) {
   const WatcherKey key(entry_path, recursive);
   const Watchers::iterator it = watchers_.find(key);
   // Check if the entry is still watched.
   if (it == watchers_.end())
     return;
 
   // Another following notification finished earlier.
   if (it->second.last_tag != last_tag)
     return;
 
   // It's illegal to provide a tag which is not unique. As for now only an error
   // message is printed, but we may want to pass the error to the providing
   // extension. TODO(mtomasz): Consider it.
   if (!tag.empty() && tag == it->second.last_tag)
     LOG(ERROR) << "Tag specified, but same as the previous one.";
 
   it->second.last_tag = tag;
 
   FOR_EACH_OBSERVER(ProvidedFileSystemObserver,
                     observers_,
                     OnWatcherTagUpdated(file_system_info_, it->second));
 
   // If the watched entry is deleted, then remove the watcher.
-  if (change_type == ProvidedFileSystemObserver::DELETED) {
+  if (change_type == storage::WatcherManager::DELETED) {
     // Make a copy, since the |it| iterator will get invalidated on the last
     // subscriber.
     Subscribers subscribers = it->second.subscribers;
     for (const auto& subscriber_it : subscribers) {
       RemoveWatcher(subscriber_it.second.origin,
                     entry_path,
                     recursive,
                     base::Bind(&EmptyStatusCallback));
     }
   }
 }
 
 }  // namespace file_system_provider
 }  // namespace chromeos