[fsp] Add throttling for number of opened files.

chrome/browser/chromeos/file_system_provider/fake_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/fake_provided_file_system.h"
 
 #include "base/message_loop/message_loop_proxy.h"
 #include "net/base/io_buffer.h"
 
 namespace chromeos {
@@ skipping 61 matching lines @@
 
 const FakeEntry* FakeProvidedFileSystem::GetEntry(
     const base::FilePath& entry_path) const {
   const Entries::const_iterator entry_it = entries_.find(entry_path);
   if (entry_it == entries_.end())
     return NULL;
 
   return entry_it->second.get();
 }
 
-ProvidedFileSystemInterface::AbortCallback
-FakeProvidedFileSystem::RequestUnmount(
+AbortCallback FakeProvidedFileSystem::RequestUnmount(
     const storage::AsyncFileUtil::StatusCallback& callback) {
   return PostAbortableTask(base::Bind(callback, base::File::FILE_OK));
 }
 
-ProvidedFileSystemInterface::AbortCallback FakeProvidedFileSystem::GetMetadata(
+AbortCallback FakeProvidedFileSystem::GetMetadata(
     const base::FilePath& entry_path,
     ProvidedFileSystemInterface::MetadataFieldMask fields,
     const ProvidedFileSystemInterface::GetMetadataCallback& callback) {
   const Entries::const_iterator entry_it = entries_.find(entry_path);
 
   if (entry_it == entries_.end()) {
     return PostAbortableTask(
         base::Bind(callback,
                    base::Passed(make_scoped_ptr<EntryMetadata>(NULL)),
                    base::File::FILE_ERROR_NOT_FOUND));
   }
 
   scoped_ptr<EntryMetadata> metadata(new EntryMetadata);
   metadata->is_directory = entry_it->second->metadata->is_directory;
   metadata->name = entry_it->second->metadata->name;
   metadata->size = entry_it->second->metadata->size;
   metadata->modification_time = entry_it->second->metadata->modification_time;
   metadata->mime_type = entry_it->second->metadata->mime_type;
   metadata->thumbnail = entry_it->second->metadata->thumbnail;
 
   return PostAbortableTask(
       base::Bind(callback, base::Passed(&metadata), base::File::FILE_OK));
 }
 
-ProvidedFileSystemInterface::AbortCallback
-FakeProvidedFileSystem::ReadDirectory(
+AbortCallback FakeProvidedFileSystem::ReadDirectory(
     const base::FilePath& directory_path,
     const storage::AsyncFileUtil::ReadDirectoryCallback& callback) {
   storage::AsyncFileUtil::EntryList entry_list;
 
   for (Entries::const_iterator it = entries_.begin(); it != entries_.end();
        ++it) {
     const base::FilePath file_path = it->first;
     if (file_path == directory_path || directory_path.IsParent(file_path)) {
       const EntryMetadata* const metadata = it->second->metadata.get();
       entry_list.push_back(storage::DirectoryEntry(
           metadata->name,
           metadata->is_directory ? storage::DirectoryEntry::DIRECTORY
                                  : storage::DirectoryEntry::FILE,
           metadata->size,
           metadata->modification_time));
     }
   }
 
   return PostAbortableTask(base::Bind(
       callback, base::File::FILE_OK, entry_list, false /* has_more */));
 }
 
-ProvidedFileSystemInterface::AbortCallback FakeProvidedFileSystem::OpenFile(
+AbortCallback FakeProvidedFileSystem::OpenFile(
     const base::FilePath& entry_path,
     OpenFileMode mode,
     const OpenFileCallback& callback) {
   const Entries::const_iterator entry_it = entries_.find(entry_path);
 
   if (entry_it == entries_.end()) {
     return PostAbortableTask(base::Bind(
         callback, 0 /* file_handle */, base::File::FILE_ERROR_NOT_FOUND));
   }
 
   const int file_handle = ++last_file_handle_;
   opened_files_[file_handle] = entry_path;
   return PostAbortableTask(
       base::Bind(callback, file_handle, base::File::FILE_OK));
 }
 
-ProvidedFileSystemInterface::AbortCallback FakeProvidedFileSystem::CloseFile(
+AbortCallback FakeProvidedFileSystem::CloseFile(
     int file_handle,
     const storage::AsyncFileUtil::StatusCallback& callback) {
   const OpenedFilesMap::iterator opened_file_it =
       opened_files_.find(file_handle);
 
   if (opened_file_it == opened_files_.end()) {
     return PostAbortableTask(
         base::Bind(callback, base::File::FILE_ERROR_NOT_FOUND));
   }
 
   opened_files_.erase(opened_file_it);
   return PostAbortableTask(base::Bind(callback, base::File::FILE_OK));
 }
 
-ProvidedFileSystemInterface::AbortCallback FakeProvidedFileSystem::ReadFile(
+AbortCallback FakeProvidedFileSystem::ReadFile(
     int file_handle,
     net::IOBuffer* buffer,
     int64 offset,
     int length,
     const ProvidedFileSystemInterface::ReadChunkReceivedCallback& callback) {
   const OpenedFilesMap::iterator opened_file_it =
       opened_files_.find(file_handle);
 
   if (opened_file_it == opened_files_.end() ||
       opened_file_it->second.AsUTF8Unsafe() != kFakeFilePath) {
@@ skipping 40 matching lines @@
     task_ids.push_back(task_id);
     current_offset++;
     current_length--;
   }
 
   return base::Bind(&FakeProvidedFileSystem::AbortMany,
                     weak_ptr_factory_.GetWeakPtr(),
                     task_ids);
 }
 
-ProvidedFileSystemInterface::AbortCallback
-FakeProvidedFileSystem::CreateDirectory(
+AbortCallback FakeProvidedFileSystem::CreateDirectory(
     const base::FilePath& directory_path,
     bool recursive,
     const storage::AsyncFileUtil::StatusCallback& callback) {
   // TODO(mtomasz): Implement it once needed.
   return PostAbortableTask(base::Bind(callback, base::File::FILE_OK));
 }
 
-ProvidedFileSystemInterface::AbortCallback FakeProvidedFileSystem::DeleteEntry(
+AbortCallback FakeProvidedFileSystem::DeleteEntry(
     const base::FilePath& entry_path,
     bool recursive,
     const storage::AsyncFileUtil::StatusCallback& callback) {
   // TODO(mtomasz): Implement it once needed.
   return PostAbortableTask(base::Bind(callback, base::File::FILE_OK));
 }
 
-ProvidedFileSystemInterface::AbortCallback FakeProvidedFileSystem::CreateFile(
+AbortCallback FakeProvidedFileSystem::CreateFile(
     const base::FilePath& file_path,
     const storage::AsyncFileUtil::StatusCallback& callback) {
   const base::File::Error result = file_path.AsUTF8Unsafe() != kFakeFilePath
                                        ? base::File::FILE_ERROR_EXISTS
                                        : base::File::FILE_OK;
 
   return PostAbortableTask(base::Bind(callback, result));
 }
 
-ProvidedFileSystemInterface::AbortCallback FakeProvidedFileSystem::CopyEntry(
+AbortCallback FakeProvidedFileSystem::CopyEntry(
     const base::FilePath& source_path,
     const base::FilePath& target_path,
     const storage::AsyncFileUtil::StatusCallback& callback) {
   // TODO(mtomasz): Implement it once needed.
   return PostAbortableTask(base::Bind(callback, base::File::FILE_OK));
 }
 
-ProvidedFileSystemInterface::AbortCallback FakeProvidedFileSystem::MoveEntry(
+AbortCallback FakeProvidedFileSystem::MoveEntry(
     const base::FilePath& source_path,
     const base::FilePath& target_path,
     const storage::AsyncFileUtil::StatusCallback& callback) {
   // TODO(mtomasz): Implement it once needed.
   return PostAbortableTask(base::Bind(callback, base::File::FILE_OK));
 }
 
-ProvidedFileSystemInterface::AbortCallback FakeProvidedFileSystem::Truncate(
+AbortCallback FakeProvidedFileSystem::Truncate(
     const base::FilePath& file_path,
     int64 length,
     const storage::AsyncFileUtil::StatusCallback& callback) {
   // TODO(mtomasz): Implement it once needed.
   return PostAbortableTask(base::Bind(callback, base::File::FILE_OK));
 }
 
-ProvidedFileSystemInterface::AbortCallback FakeProvidedFileSystem::WriteFile(
+AbortCallback FakeProvidedFileSystem::WriteFile(
     int file_handle,
     net::IOBuffer* buffer,
     int64 offset,
     int length,
     const storage::AsyncFileUtil::StatusCallback& callback) {
   const OpenedFilesMap::iterator opened_file_it =
       opened_files_.find(file_handle);
 
   if (opened_file_it == opened_files_.end() ||
       opened_file_it->second.AsUTF8Unsafe() != kFakeFilePath) {
@@ skipping 17 matching lines @@
   if (offset + length > entry->metadata->size) {
     entry->metadata->size = offset + length;
     entry->contents.resize(entry->metadata->size);
   }
 
   entry->contents.replace(offset, length, buffer->data(), length);
 
   return PostAbortableTask(base::Bind(callback, base::File::FILE_OK));
 }
 
-ProvidedFileSystemInterface::AbortCallback FakeProvidedFileSystem::AddWatcher(
+AbortCallback FakeProvidedFileSystem::AddWatcher(
     const GURL& origin,
     const base::FilePath& entry_watcher,
     bool recursive,
     bool persistent,
     const storage::AsyncFileUtil::StatusCallback& callback,
     const storage::WatcherManager::NotificationCallback&
         notification_callback) {
   // TODO(mtomasz): Implement it once needed.
   return PostAbortableTask(base::Bind(callback, base::File::FILE_OK));
 }
@@ skipping 47 matching lines @@
     Profile* profile,
     const ProvidedFileSystemInfo& file_system_info) {
   return new FakeProvidedFileSystem(file_system_info);
 }
 
 base::WeakPtr<ProvidedFileSystemInterface>
 FakeProvidedFileSystem::GetWeakPtr() {
   return weak_ptr_factory_.GetWeakPtr();
 }
 
-ProvidedFileSystemInterface::AbortCallback
-FakeProvidedFileSystem::PostAbortableTask(const base::Closure& callback) {
+AbortCallback FakeProvidedFileSystem::PostAbortableTask(
+    const base::Closure& callback) {
   const int task_id = tracker_.PostTask(
       base::MessageLoopProxy::current().get(), FROM_HERE, callback);
   return base::Bind(
       &FakeProvidedFileSystem::Abort, weak_ptr_factory_.GetWeakPtr(), task_id);
 }
 
 void FakeProvidedFileSystem::Abort(
     int task_id,
     const storage::AsyncFileUtil::StatusCallback& callback) {
   tracker_.TryCancel(task_id);
   callback.Run(base::File::FILE_OK);
 }
 
 void FakeProvidedFileSystem::AbortMany(
     const std::vector<int>& task_ids,
     const storage::AsyncFileUtil::StatusCallback& callback) {
   for (size_t i = 0; i < task_ids.size(); ++i) {
     tracker_.TryCancel(task_ids[i]);
   }
   callback.Run(base::File::FILE_OK);
 }
 
 }  // namespace file_system_provider
 }  // namespace chromeos