[fsp] Add support for observing entries and notifying about changes.

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"
 #include "chrome/browser/chromeos/file_system_provider/notification_manager.h"
 #include "chrome/browser/chromeos/file_system_provider/operations/abort.h"
 #include "chrome/browser/chromeos/file_system_provider/operations/close_file.h"
 #include "chrome/browser/chromeos/file_system_provider/operations/copy_entry.h"
 #include "chrome/browser/chromeos/file_system_provider/operations/create_directory.h"
 #include "chrome/browser/chromeos/file_system_provider/operations/create_file.h"
 #include "chrome/browser/chromeos/file_system_provider/operations/delete_entry.h"
 #include "chrome/browser/chromeos/file_system_provider/operations/get_metadata.h"
 #include "chrome/browser/chromeos/file_system_provider/operations/move_entry.h"
+#include "chrome/browser/chromeos/file_system_provider/operations/observe_directory.h"
 #include "chrome/browser/chromeos/file_system_provider/operations/open_file.h"
 #include "chrome/browser/chromeos/file_system_provider/operations/read_directory.h"
 #include "chrome/browser/chromeos/file_system_provider/operations/read_file.h"
 #include "chrome/browser/chromeos/file_system_provider/operations/truncate.h"
 #include "chrome/browser/chromeos/file_system_provider/operations/unmount.h"
+#include "chrome/browser/chromeos/file_system_provider/operations/unobserve_entry.h"
 #include "chrome/browser/chromeos/file_system_provider/operations/write_file.h"
 #include "chrome/browser/chromeos/file_system_provider/request_manager.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/common/extensions/api/file_system_provider.h"
 #include "extensions/browser/event_router.h"
 
 namespace net {
 class IOBuffer;
 }  // namespace net
 
 namespace chromeos {
 namespace file_system_provider {
 namespace {
 
 // Dicards the result of Abort() when called from the destructor.
 void EmptyStatusCallback(base::File::Error /* result */) {
 }
 
+// Handles
+
 }  // namespace
 
 ProvidedFileSystem::ProvidedFileSystem(
     Profile* profile,
     const ProvidedFileSystemInfo& file_system_info)
     : profile_(profile),
       event_router_(extensions::EventRouter::Get(profile)),  // May be NULL.
       file_system_info_(file_system_info),
       notification_manager_(
           new NotificationManager(profile_, file_system_info_)),
@@ skipping 257 matching lines @@
           event_router_, file_system_info_, file_path, length, callback)));
   if (!request_id) {
     callback.Run(base::File::FILE_ERROR_SECURITY);
     return AbortCallback();
   }
 
   return base::Bind(
       &ProvidedFileSystem::Abort, weak_ptr_factory_.GetWeakPtr(), request_id);
 }
 
+ProvidedFileSystem::AbortCallback ProvidedFileSystem::ObserveDirectory(
+    const base::FilePath& directory_path,
+    bool recursive,
+    const storage::AsyncFileUtil::StatusCallback& callback) {
+  // TODO(mtomasz): Wrap with an asynchronous queue.
+  const int request_id = request_manager_.CreateRequest(
+      OBSERVE_DIRECTORY,
+      scoped_ptr<RequestManager::HandlerInterface>(
+          new operations::ObserveDirectory(
+              event_router_,
+              file_system_info_,
+              directory_path,
+              recursive,
+              base::Bind(&ProvidedFileSystem::OnObserveDirectoryCompleted,
+                         weak_ptr_factory_.GetWeakPtr(),
+                         directory_path,
+                         recursive,
+                         callback))));
+  if (!request_id) {
+    callback.Run(base::File::FILE_ERROR_SECURITY);
+    return AbortCallback();
+  }
+
+  return base::Bind(
+      &ProvidedFileSystem::Abort, weak_ptr_factory_.GetWeakPtr(), request_id);
+}
+
+ProvidedFileSystem::AbortCallback ProvidedFileSystem::UnobserveEntry(
+    const base::FilePath& entry_path,
+    const storage::AsyncFileUtil::StatusCallback& callback) {
+  // TODO(mtomasz): Wrap with an asynchronous queue.
+  const ObservedEntries::const_iterator it = observed_entries_.find(entry_path);
+  if (it != observed_entries_.end()) {
+    callback.Run(base::File::FILE_ERROR_NOT_FOUND);
+    return AbortCallback();
+  }
+
+  // Delete the watcher in advance since the list of observed entries is owned
+  // by the C++ layer, not by the extension.
+  observed_entries_.erase(it);
+
+  FOR_EACH_OBSERVER(Observer, observers_, OnObservedEntriesListChanged());
+
+  // TODO(mtomasz): Consider returning always an OK error code, since for the
+  // callers it's important that the entry is not watched anymore. The watcher
+  // is removed even if the extension returns an error.
+  const int request_id = request_manager_.CreateRequest(
+      UNOBSERVE_ENTRY,
+      scoped_ptr<RequestManager::HandlerInterface>(
+          new operations::UnobserveEntry(
+              event_router_, file_system_info_, entry_path, callback)));
+  if (!request_id) {
+    callback.Run(base::File::FILE_ERROR_SECURITY);
+    return AbortCallback();
+  }
+
+  return base::Bind(
+      &ProvidedFileSystem::Abort, weak_ptr_factory_.GetWeakPtr(), request_id);
+}
+
 const ProvidedFileSystemInfo& ProvidedFileSystem::GetFileSystemInfo() const {
   return file_system_info_;
 }
 
 RequestManager* ProvidedFileSystem::GetRequestManager() {
   return &request_manager_;
 }
 
+ProvidedFileSystem::ObservedEntries* ProvidedFileSystem::GetObservedEntries() {
+  return &observed_entries_;
+}
+
+void ProvidedFileSystem::AddObserver(Observer* observer) {
+  DCHECK(observer);
+  observers_.AddObserver(observer);
+}
+
+void ProvidedFileSystem::RemoveObserver(Observer* observer) {
+  DCHECK(observer);
+  observers_.RemoveObserver(observer);
+}
+
+ObserverList<ProvidedFileSystemInterface::Observer>*
+ProvidedFileSystem::GetObservers() {
+  return &observers_;
+}
+
 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::OnObserveDirectoryCompleted(
+    const base::FilePath& directory_path,
+    bool recursive,
+    const storage::AsyncFileUtil::StatusCallback& callback,
+    base::File::Error result) {
+  if (result != base::File::FILE_OK) {
+    callback.Run(result);
+    return;
+  }
+
+  observed_entries_[directory_path].entry_path = directory_path;
+  observed_entries_[directory_path].recursive |= recursive;
+
+  FOR_EACH_OBSERVER(Observer, observers_, OnObservedEntriesListChanged());
+
+  callback.Run(result);
+}
+
 }  // namespace file_system_provider
 }  // namespace chromeos