[Quota][FileAPI] Add quota policy to FileSystemOperationContext

chrome/browser/chromeos/drive/file_system_proxy.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 "chrome/browser/chromeos/drive/file_system_proxy.h"
 
 #include <string>
 #include <vector>
 
 #include "base/bind.h"
@@ skipping 24 matching lines @@
 
 const char kFeedField[] = "feed";
 
 // Helper function to run reply on results of base::CreatePlatformFile() on
 // IO thread.
 void OnPlatformFileOpened(
     const FileSystemOperation::OpenFileCallback& callback,
     base::ProcessHandle peer_handle,
     base::PlatformFileError* open_error,
     base::PlatformFile platform_file) {
-  callback.Run(*open_error, platform_file, peer_handle);
+  callback.Run(*open_error, platform_file, peer_handle,
+               quota::kQuotaLimitTypeLimited);
 }
 
 // Helper function to run OpenFileCallback from
 // FileSystemProxy::OpenFile().
 void OnGetFileByPathForOpen(
     const FileSystemOperation::OpenFileCallback& callback,
     int file_flags,
     base::ProcessHandle peer_handle,
     FileError file_error,
     const base::FilePath& local_path,
     const std::string& unused_mime_type,
     DriveFileType file_type) {
   base::PlatformFileError error =
       FileErrorToPlatformError(file_error);
   if (error != base::PLATFORM_FILE_OK) {
-    callback.Run(error, base::kInvalidPlatformFileValue, peer_handle);
+    callback.Run(error, base::kInvalidPlatformFileValue, peer_handle,
+                 quota::kQuotaLimitTypeLimited);
     return;
   }
 
   base::PlatformFileError* open_error =
       new base::PlatformFileError(base::PLATFORM_FILE_ERROR_FAILED);
   base::PostTaskAndReplyWithResult(
       BrowserThread::GetBlockingPool(),
       FROM_HERE,
       base::Bind(&base::CreatePlatformFile,
                  local_path,
@@ skipping 325 matching lines @@
     base::ProcessHandle peer_handle,
     const FileSystemOperation::OpenFileCallback& callback,
     FileError file_error,
     const base::FilePath& local_cache_path) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
   base::PlatformFileError error =
       FileErrorToPlatformError(file_error);
 
   if (error != base::PLATFORM_FILE_OK) {
-    callback.Run(error, base::kInvalidPlatformFileValue, peer_handle);
+    callback.Run(error, base::kInvalidPlatformFileValue, peer_handle,
+                 quota::kQuotaLimitTypeLimited);
     return;
   }
 
   // Cache file prepared for modification is available. Truncate it.
   base::PlatformFileError* result =
       new base::PlatformFileError(base::PLATFORM_FILE_ERROR_FAILED);
   bool posted = base::PostTaskAndReplyWithResult(
       BrowserThread::GetBlockingPool(), FROM_HERE,
       base::Bind(&base::CreatePlatformFile,
                  local_cache_path,
@@ skipping 19 matching lines @@
 
   if ((create_result == base::PLATFORM_FILE_OK) ||
       ((create_result == base::PLATFORM_FILE_ERROR_EXISTS) &&
        (file_flags & base::PLATFORM_FILE_CREATE_ALWAYS))) {
     // If we are trying to always create an existing file, then
     // if it really exists open it as truncated.
     file_flags &= ~base::PLATFORM_FILE_CREATE;
     file_flags &= ~base::PLATFORM_FILE_CREATE_ALWAYS;
     file_flags |= base::PLATFORM_FILE_OPEN_TRUNCATED;
   } else {
-    callback.Run(create_result, base::kInvalidPlatformFileValue, peer_handle);
+    callback.Run(create_result, base::kInvalidPlatformFileValue, peer_handle,
+                 quota::kQuotaLimitTypeLimited);
     return;
   }
 
   // Open created (or existing) file for writing.
   CallDriveFileSystemMethodOnUIThread(
       base::Bind(&DriveFileSystemInterface::OpenFile,
                  base::Unretained(file_system_),
                  file_path,
                  google_apis::CreateRelayCallback(
                      base::Bind(&FileSystemProxy::OnOpenFileForWriting,
@@ skipping 55 matching lines @@
     const FileSystemOperation::OpenFileCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
   base::FilePath file_path;
   if (!ValidateUrl(file_url, &file_path)) {
     MessageLoopProxy::current()->PostTask(
         FROM_HERE,
         base::Bind(callback,
                    base::PLATFORM_FILE_ERROR_NOT_FOUND,
                    base::kInvalidPlatformFileValue,
-                   peer_handle));
+                   peer_handle,
+                   quota::kQuotaLimitTypeLimited));
     return;
   }
 
   // TODO(zelidrag): Wire all other file open operations.
   if ((file_flags & base::PLATFORM_FILE_DELETE_ON_CLOSE)) {
     NOTIMPLEMENTED() << "File create/write operations not yet supported "
                      << file_path.value();
     MessageLoopProxy::current()->PostTask(
         FROM_HERE,
         base::Bind(callback,
                    base::PLATFORM_FILE_ERROR_FAILED,
                    base::kInvalidPlatformFileValue,
-                   peer_handle));
+                   peer_handle,
+                   quota::kQuotaLimitTypeLimited));
     return;
   }
 
   if ((file_flags & base::PLATFORM_FILE_OPEN) ||
       (file_flags & base::PLATFORM_FILE_OPEN_ALWAYS) ||
       (file_flags & base::PLATFORM_FILE_OPEN_TRUNCATED)) {
     if ((file_flags & base::PLATFORM_FILE_OPEN_TRUNCATED) ||
         (file_flags & base::PLATFORM_FILE_OPEN_ALWAYS) ||
         (file_flags & base::PLATFORM_FILE_WRITE) ||
         (file_flags & base::PLATFORM_FILE_EXCLUSIVE_WRITE)) {
@@ skipping 35 matching lines @@
                                   file_flags,
                                   peer_handle,
                                   callback))));
   } else {
     NOTREACHED() << "Unhandled file flags combination " << file_flags;
     MessageLoopProxy::current()->PostTask(
         FROM_HERE,
         base::Bind(callback,
                    base::PLATFORM_FILE_ERROR_FAILED,
                    base::kInvalidPlatformFileValue,
-                   peer_handle));
+                   peer_handle,
+                   quota::kQuotaLimitTypeLimited));
   }
 }
 
 void FileSystemProxy::NotifyCloseFile(const FileSystemURL& url) {
   base::FilePath file_path;
   if (!ValidateUrl(url, &file_path))
     return;
 
   CallDriveFileSystemMethodOnUIThread(
       base::Bind(&DriveFileSystemInterface::CloseFile,
@@ skipping 223 matching lines @@
   CallDriveFileSystemMethodOnUIThread(
       base::Bind(&DriveFileSystemInterface::CloseFile,
                  base::Unretained(file_system_),
                  virtual_path,
                  google_apis::CreateRelayCallback(
                      base::Bind(&EmitDebugLogForCloseFile,
                                 virtual_path))));
 }
 
 }  // namespace drive