[fsp] Rename ObserveEntry with AddWatcher.

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/add_watcher.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/remove_watcher.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
 
@@ skipping 320 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(
+ProvidedFileSystem::AbortCallback ProvidedFileSystem::AddWatcher(
     const GURL& origin,
-    const base::FilePath& directory_path,
+    const base::FilePath& entry_path,
     bool recursive,
     bool persistent,
     const storage::AsyncFileUtil::StatusCallback& callback) {
   // TODO(mtomasz): Wrap the entire method body with an asynchronous queue to
   // avoid races.
   if (persistent && !file_system_info_.supports_notify_tag()) {
-    OnObserveDirectoryCompleted(origin,
-                                directory_path,
-                                recursive,
-                                persistent,
-                                callback,
-                                base::File::FILE_ERROR_INVALID_OPERATION);
+    OnAddWatcherCompleted(origin,
+                          entry_path,
+                          recursive,
+                          persistent,
+                          callback,
+                          base::File::FILE_ERROR_INVALID_OPERATION);
     return AbortCallback();
   }
 
-  const ObservedEntryKey key(directory_path, recursive);
-  const ObservedEntries::const_iterator it = observed_entries_.find(key);
-  if (it != observed_entries_.end()) {
+  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();
-    OnObserveDirectoryCompleted(
+    OnAddWatcherCompleted(
         origin,
-        directory_path,
+        entry_path,
         recursive,
         persistent,
         callback,
         exists ? base::File::FILE_ERROR_EXISTS : base::File::FILE_OK);
     return AbortCallback();
   }
 
   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(),
-                         origin,
-                         directory_path,
-                         recursive,
-                         persistent,
-                         callback))));
+      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,
+                     callback))));
 
   if (!request_id) {
-    OnObserveDirectoryCompleted(origin,
-                                directory_path,
-                                recursive,
-                                persistent,
-                                callback,
-                                base::File::FILE_ERROR_SECURITY);
+    OnAddWatcherCompleted(origin,
+                          entry_path,
+                          recursive,
+                          persistent,
+                          callback,
+                          base::File::FILE_ERROR_SECURITY);
     return AbortCallback();
   }
 
   return base::Bind(
       &ProvidedFileSystem::Abort, weak_ptr_factory_.GetWeakPtr(), request_id);
 }
 
-void ProvidedFileSystem::UnobserveEntry(
+void ProvidedFileSystem::RemoveWatcher(
     const GURL& origin,
     const base::FilePath& entry_path,
     bool recursive,
     const storage::AsyncFileUtil::StatusCallback& callback) {
-  const ObservedEntryKey key(entry_path, recursive);
-  const ObservedEntries::iterator it = observed_entries_.find(key);
-  if (it == observed_entries_.end() ||
+  const WatcherKey key(entry_path, recursive);
+  const Watchers::iterator it = watchers_.find(key);
+  if (it == watchers_.end() ||
       it->second.subscribers.find(origin) == it->second.subscribers.end()) {
     callback.Run(base::File::FILE_ERROR_NOT_FOUND);
     return;
   }
 
-  // Delete the subscriber in advance, since the list of observed entries is
-  // owned by the C++ layer, not by the extension.
+  // Delete the subscriber in advance, since the list of watchers is owned by
+  // the C++ layer, not by the extension.
   it->second.subscribers.erase(origin);
 
-  FOR_EACH_OBSERVER(
-      ProvidedFileSystemObserver,
-      observers_,
-      OnObservedEntryListChanged(file_system_info_, observed_entries_));
+  FOR_EACH_OBSERVER(ProvidedFileSystemObserver,
+                    observers_,
+                    OnWatcherListChanged(file_system_info_, watchers_));
 
   // If there are other subscribers, then do not remove the obsererver, but
   // simply return a success.
   if (it->second.subscribers.size()) {
     callback.Run(base::File::FILE_OK);
     return;
   }
 
   // Delete the watcher in advance.
-  observed_entries_.erase(it);
+  watchers_.erase(it);
 
   // Even if the extension returns an error, the callback is called with base::
-  // File::FILE_OK. The reason for that is that the observed is not watched
-  // anymore anyway, as it's removed in advance.
+  // File::FILE_OK. The reason for that is that the entry is not watche anymore
+  // anyway, as it's removed in advance.
   const int request_id = request_manager_->CreateRequest(
-      UNOBSERVE_ENTRY,
+      REMOVE_WATCHER,
       scoped_ptr<RequestManager::HandlerInterface>(
-          new operations::UnobserveEntry(
+          new operations::RemoveWatcher(
               event_router_,
               file_system_info_,
               entry_path,
               recursive,
               base::Bind(&AlwaysSuccessCallback, callback))));
   if (!request_id)
     callback.Run(base::File::FILE_OK);
 }
 
 const ProvidedFileSystemInfo& ProvidedFileSystem::GetFileSystemInfo() const {
   return file_system_info_;
 }
 
 RequestManager* ProvidedFileSystem::GetRequestManager() {
   return request_manager_.get();
 }
 
-ObservedEntries* ProvidedFileSystem::GetObservedEntries() {
-  return &observed_entries_;
+Watchers* ProvidedFileSystem::GetWatchers() {
+  return &watchers_;
 }
 
 void ProvidedFileSystem::AddObserver(ProvidedFileSystemObserver* observer) {
   DCHECK(observer);
   observers_.AddObserver(observer);
 }
 
 void ProvidedFileSystem::RemoveObserver(ProvidedFileSystemObserver* observer) {
   DCHECK(observer);
   observers_.RemoveObserver(observer);
 }
 
 bool ProvidedFileSystem::Notify(
-    const base::FilePath& observed_path,
+    const base::FilePath& entry_path,
     bool recursive,
     ProvidedFileSystemObserver::ChangeType change_type,
     scoped_ptr<ProvidedFileSystemObserver::Changes> changes,
     const std::string& tag) {
-  const ObservedEntryKey key(observed_path, recursive);
-  const ObservedEntries::iterator it = observed_entries_.find(key);
-  if (it == observed_entries_.end())
+  const WatcherKey key(entry_path, recursive);
+  const Watchers::iterator it = watchers_.find(key);
+  if (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(),
-                                 observed_path,
+                                 entry_path,
                                  recursive,
                                  change_type,
                                  base::Passed(&changes),
                                  it->second.last_tag,
                                  tag)));
 
   FOR_EACH_OBSERVER(ProvidedFileSystemObserver,
                     observers_,
-                    OnObservedEntryChanged(file_system_info_,
-                                           it->second,
-                                           change_type,
-                                           changes_ref,
-                                           auto_updater->CreateCallback()));
+                    OnWatcherChanged(file_system_info_,
+                                     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::OnObserveDirectoryCompleted(
+void ProvidedFileSystem::OnAddWatcherCompleted(
     const GURL& origin,
-    const base::FilePath& directory_path,
+    const base::FilePath& entry_path,
     bool recursive,
     bool persistent,
     const storage::AsyncFileUtil::StatusCallback& callback,
     base::File::Error result) {
   if (result != base::File::FILE_OK) {
     callback.Run(result);
     return;
   }
 
-  const ObservedEntryKey key(directory_path, recursive);
-  const ObservedEntries::iterator it = observed_entries_.find(key);
-  if (it != observed_entries_.end()) {
+  const WatcherKey key(entry_path, recursive);
+  const Watchers::iterator it = watchers_.find(key);
+  if (it != watchers_.end()) {
     callback.Run(base::File::FILE_OK);
     return;
   }
 
-  ObservedEntry* const observed_entry = &observed_entries_[key];
-  observed_entry->entry_path = directory_path;
-  observed_entry->recursive = recursive;
-  observed_entry->subscribers[origin].origin = origin;
-  observed_entry->subscribers[origin].persistent |= persistent;
+  Watcher* const watcher = &watchers_[key];
+  watcher->entry_path = entry_path;
+  watcher->recursive = recursive;
+  watcher->subscribers[origin].origin = origin;
+  watcher->subscribers[origin].persistent |= persistent;
 
-  FOR_EACH_OBSERVER(
-      ProvidedFileSystemObserver,
-      observers_,
-      OnObservedEntryListChanged(file_system_info_, observed_entries_));
+  FOR_EACH_OBSERVER(ProvidedFileSystemObserver,
+                    observers_,
+                    OnWatcherListChanged(file_system_info_, watchers_));
 
   callback.Run(base::File::FILE_OK);
 }
 
 void ProvidedFileSystem::OnNotifyCompleted(
-    const base::FilePath& observed_path,
+    const base::FilePath& entry_path,
     bool recursive,
     ProvidedFileSystemObserver::ChangeType change_type,
     scoped_ptr<ProvidedFileSystemObserver::Changes> /* changes */,
     const std::string& last_tag,
     const std::string& tag) {
-  const ObservedEntryKey key(observed_path, recursive);
-  const ObservedEntries::iterator it = observed_entries_.find(key);
-  // Check if the entry is still observed.
-  if (it == observed_entries_.end())
+  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_,
-                    OnObservedEntryTagUpdated(file_system_info_, it->second));
+                    OnWatcherTagUpdated(file_system_info_, it->second));
 
-  // If the observed entry is deleted, then unobserve it.
+  // If the watched entry is deleted, then remove the watcher.
   if (change_type == ProvidedFileSystemObserver::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) {
-      UnobserveEntry(subscriber_it.second.origin,
-                     observed_path,
-                     recursive,
-                     base::Bind(&EmptyStatusCallback));
+      RemoveWatcher(subscriber_it.second.origin,
+                    entry_path,
+                    recursive,
+                    base::Bind(&EmptyStatusCallback));
     }
   }
 }
 
 }  // namespace file_system_provider
 }  // namespace chromeos