Simplify file_system_provider::Queue.

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/files/file.h"
 #include "base/trace_event/trace_event.h"
@@ skipping 636 matching lines @@
 void ProvidedFileSystem::OnAddWatcherInQueueCompleted(
     size_t token,
     const base::FilePath& entry_path,
     bool recursive,
     const Subscriber& subscriber,
     const storage::AsyncFileUtil::StatusCallback& callback,
     base::File::Error result) {
   if (result != base::File::FILE_OK) {
     callback.Run(result);
     watcher_queue_.Complete(token);
-    watcher_queue_.Remove(token);
     return;
   }
 
   const WatcherKey key(entry_path, recursive);
   const Watchers::iterator it = watchers_.find(key);
   if (it != watchers_.end()) {
     callback.Run(base::File::FILE_OK);
     watcher_queue_.Complete(token);
-    watcher_queue_.Remove(token);
     return;
   }
 
   Watcher* const watcher = &watchers_[key];
   watcher->entry_path = entry_path;
   watcher->recursive = recursive;
   watcher->subscribers[subscriber.origin] = subscriber;
 
   FOR_EACH_OBSERVER(ProvidedFileSystemObserver,
                     observers_,
                     OnWatcherListChanged(file_system_info_, watchers_));
 
   callback.Run(base::File::FILE_OK);
   watcher_queue_.Complete(token);
-  watcher_queue_.Remove(token);
 }
 
 void ProvidedFileSystem::OnRemoveWatcherInQueueCompleted(
     size_t token,
     const GURL& origin,
     const WatcherKey& key,
     const storage::AsyncFileUtil::StatusCallback& callback,
     bool extension_response,
     base::File::Error result) {
   if (!extension_response && result != base::File::FILE_OK) {
     watcher_queue_.Complete(token);
-    watcher_queue_.Remove(token);
     callback.Run(result);
     return;
   }
 
   // Even if the extension returns an error, the callback is called with base::
   // File::FILE_OK.
   const auto it = watchers_.find(key);
   DCHECK(it != watchers_.end());
   DCHECK(it->second.subscribers.find(origin) != it->second.subscribers.end());
 
   it->second.subscribers.erase(origin);
 
   FOR_EACH_OBSERVER(ProvidedFileSystemObserver, observers_,
                     OnWatcherListChanged(file_system_info_, watchers_));
 
   // If there are no more subscribers, then remove the watcher.
   if (!it->second.subscribers.size())
     watchers_.erase(it);
 
   callback.Run(base::File::FILE_OK);
   watcher_queue_.Complete(token);
-  watcher_queue_.Remove(token);
 }
 
 void ProvidedFileSystem::OnNotifyInQueueCompleted(
     scoped_ptr<NotifyInQueueArgs> args,
     base::File::Error result) {
   if (result != base::File::FILE_OK) {
     args->callback.Run(result);
     watcher_queue_.Complete(args->token);
-    watcher_queue_.Remove(args->token);
     return;
   }
 
   // Check if the entry is still watched.
   const WatcherKey key(args->entry_path, args->recursive);
   const Watchers::iterator it = watchers_.find(key);
   if (it == watchers_.end()) {
     args->callback.Run(base::File::FILE_ERROR_NOT_FOUND);
     watcher_queue_.Complete(args->token);
-    watcher_queue_.Remove(args->token);
     return;
   }
 
   it->second.last_tag = args->tag;
 
   FOR_EACH_OBSERVER(ProvidedFileSystemObserver,
                     observers_,
                     OnWatcherTagUpdated(file_system_info_, it->second));
 
   // If the watched entry is deleted, then remove the watcher.
   if (args->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, args->entry_path,
                     args->recursive, base::Bind(&EmptyStatusCallback));
     }
   }
 
   args->callback.Run(base::File::FILE_OK);
   watcher_queue_.Complete(args->token);
-  watcher_queue_.Remove(args->token);
 }
 
 void ProvidedFileSystem::OnOpenFileCompleted(const base::FilePath& file_path,
                                              OpenFileMode mode,
                                              const OpenFileCallback& callback,
                                              int file_handle,
                                              base::File::Error result) {
   if (result != base::File::FILE_OK) {
     callback.Run(file_handle, result);
     return;
   }
 
   opened_files_[file_handle] = OpenedFile(file_path, mode);
   callback.Run(file_handle, base::File::FILE_OK);
 }
 
 void ProvidedFileSystem::OnCloseFileCompleted(
     int file_handle,
     const storage::AsyncFileUtil::StatusCallback& callback,
     base::File::Error result) {
   // Closing files is final. Even if an error happened, we remove it from the
   // list of opened files.
   opened_files_.erase(file_handle);
   callback.Run(result);
 }
 
 }  // namespace file_system_provider
 }  // namespace chromeos