Add Quota related method to CannedSyncableFileSystem for testing

webkit/fileapi/syncable/canned_syncable_file_system.cc

 // Copyright (c) 2012 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 "webkit/fileapi/syncable/canned_syncable_file_system.h"
 
 #include "base/bind.h"
 #include "base/file_util.h"
 #include "base/message_loop_proxy.h"
 #include "base/single_thread_task_runner.h"
@@ skipping 71 matching lines @@
         return;
     }
     completion_callback.Run(error == base::PLATFORM_FILE_OK
                             ? bytes_written_ : static_cast<int64>(error));
   }
 
  private:
   int64 bytes_written_;
 };
 
+void DidGetUsageAndQuota(const quota::StatusCallback& callback,
+                         int64* usage_out, int64* quota_out,
+                         quota::QuotaStatusCode status,
+                         int64 usage, int64 quota) {
+  *usage_out = usage;
+  *quota_out = quota;
+  callback.Run(status);
+}
+
 }  // namespace
 
 CannedSyncableFileSystem::CannedSyncableFileSystem(
     const GURL& origin, const std::string& service,
     base::SingleThreadTaskRunner* io_task_runner)
     : service_name_(service),
       test_helper_(origin, kFileSystemTypeSyncable),
       result_(base::PLATFORM_FILE_OK),
       sync_status_(SYNC_STATUS_OK),
       io_task_runner_(io_task_runner),
@@ skipping 156 matching lines @@
   EXPECT_TRUE(is_filesystem_set_up_);
   return RunOnThread<PlatformFileError>(
       io_task_runner_,
       FROM_HERE,
       base::Bind(&FileSystemContext::DeleteFileSystem,
                  file_system_context_,
                  test_helper_.origin(),
                  test_helper_.type()));
 }
 
+quota::QuotaStatusCode CannedSyncableFileSystem::GetUsageAndQuota(
+    int64* usage, int64* quota) {
+  return RunOnThread<quota::QuotaStatusCode>(
+      io_task_runner_,
+      FROM_HERE,
+      base::Bind(&CannedSyncableFileSystem::DoGetUsageAndQuota,
+                 base::Unretained(this), usage, quota));
+}
+
 FileSystemOperation* CannedSyncableFileSystem::NewOperation() {
   return file_system_context_->CreateFileSystemOperation(URL(""), NULL);
 }
 
 void CannedSyncableFileSystem::DoCreateDirectory(
     const FileSystemURL& url,
     const StatusCallback& callback) {
   EXPECT_TRUE(is_filesystem_opened_);
   NewOperation()->CreateDirectory(
       url, false /* exclusive */, false /* recursive */, callback);
@@ skipping 52 matching lines @@
     net::URLRequestContext* url_request_context,
     const FileSystemURL& url, const GURL& blob_url,
     const WriteCallback& callback) {
   EXPECT_TRUE(is_filesystem_opened_);
   WriteHelper* helper = new WriteHelper;
   NewOperation()->Write(url_request_context, url, blob_url, 0,
                         base::Bind(&WriteHelper::DidWrite,
                                    base::Owned(helper), callback));
 }
 
+void CannedSyncableFileSystem::DoGetUsageAndQuota(
+    int64* usage,
+    int64* quota,
+    const quota::StatusCallback& callback) {
+  quota_manager_->GetUsageAndQuota(
+      test_helper_.origin(),
+      test_helper_.storage_type(),
+      base::Bind(&DidGetUsageAndQuota, callback, usage, quota));
+}
+
 void CannedSyncableFileSystem::DidOpenFileSystem(
     PlatformFileError result, const std::string& name, const GURL& root) {
   result_ = result;
   root_url_ = root;
   is_filesystem_opened_ = true;
 }
 
 void CannedSyncableFileSystem::DidInitializeFileSystemContext(
     SyncStatusCode status) {
   sync_status_ = status;
   MessageLoop::current()->Quit();
 }
 
 }  // namespace fileapi