Convert Media Galleries to use base::File

content/browser/fileapi/fileapi_message_filter.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 "content/browser/fileapi/fileapi_message_filter.h"
 
 #include <string>
 #include <vector>
 
 #include "base/bind.h"
@@ skipping 202 matching lines @@
 
 void FileAPIMessageFilter::OnResolveURL(
     int request_id,
     const GURL& filesystem_url) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   FileSystemURL url(context_->CrackURL(filesystem_url));
   if (!ValidateFileSystemURL(request_id, url))
     return;
   if (!security_policy_->CanReadFileSystemFile(process_id_, url)) {
     Send(new FileSystemMsg_DidFail(request_id,
-                                   base::PLATFORM_FILE_ERROR_SECURITY));
+                                   base::File::FILE_ERROR_SECURITY));
     return;
   }
 
   context_->ResolveURL(url, base::Bind(
       &FileAPIMessageFilter::DidResolveURL, this, request_id));
 }
 
 void FileAPIMessageFilter::OnDeleteFileSystem(
     int request_id,
     const GURL& origin_url,
     fileapi::FileSystemType type) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   context_->DeleteFileSystem(origin_url, type, base::Bind(
       &FileAPIMessageFilter::DidDeleteFileSystem, this, request_id));
 }
 
 void FileAPIMessageFilter::OnMove(
     int request_id, const GURL& src_path, const GURL& dest_path) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   FileSystemURL src_url(context_->CrackURL(src_path));
   FileSystemURL dest_url(context_->CrackURL(dest_path));
   if (!ValidateFileSystemURL(request_id, src_url) ||
       !ValidateFileSystemURL(request_id, dest_url)) {
     return;
   }
   if (!security_policy_->CanReadFileSystemFile(process_id_, src_url) ||
       !security_policy_->CanDeleteFileSystemFile(process_id_, src_url) ||
       !security_policy_->CanCreateFileSystemFile(process_id_, dest_url)) {
     Send(new FileSystemMsg_DidFail(request_id,
-                                   base::PLATFORM_FILE_ERROR_SECURITY));
+                                   base::File::FILE_ERROR_SECURITY));
     return;
   }
 
   operations_[request_id] = operation_runner()->Move(
       src_url, dest_url,
       fileapi::FileSystemOperation::OPTION_NONE,
       base::Bind(&FileAPIMessageFilter::DidFinish, this, request_id));
 }
 
 void FileAPIMessageFilter::OnCopy(
     int request_id, const GURL& src_path, const GURL& dest_path) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   FileSystemURL src_url(context_->CrackURL(src_path));
   FileSystemURL dest_url(context_->CrackURL(dest_path));
   if (!ValidateFileSystemURL(request_id, src_url) ||
       !ValidateFileSystemURL(request_id, dest_url)) {
     return;
   }
   if (!security_policy_->CanReadFileSystemFile(process_id_, src_url) ||
       !security_policy_->CanCopyIntoFileSystemFile(process_id_, dest_url)) {
     Send(new FileSystemMsg_DidFail(request_id,
-                                   base::PLATFORM_FILE_ERROR_SECURITY));
+                                   base::File::FILE_ERROR_SECURITY));
     return;
   }
 
   operations_[request_id] = operation_runner()->Copy(
       src_url, dest_url,
       fileapi::FileSystemOperation::OPTION_NONE,
       fileapi::FileSystemOperationRunner::CopyProgressCallback(),
       base::Bind(&FileAPIMessageFilter::DidFinish, this, request_id));
 }
 
 void FileAPIMessageFilter::OnRemove(
     int request_id, const GURL& path, bool recursive) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   FileSystemURL url(context_->CrackURL(path));
   if (!ValidateFileSystemURL(request_id, url))
     return;
   if (!security_policy_->CanDeleteFileSystemFile(process_id_, url)) {
     Send(new FileSystemMsg_DidFail(request_id,
-                                   base::PLATFORM_FILE_ERROR_SECURITY));
+                                   base::File::FILE_ERROR_SECURITY));
     return;
   }
 
   operations_[request_id] = operation_runner()->Remove(
       url, recursive,
       base::Bind(&FileAPIMessageFilter::DidFinish, this, request_id));
 }
 
 void FileAPIMessageFilter::OnReadMetadata(
     int request_id, const GURL& path) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   FileSystemURL url(context_->CrackURL(path));
   if (!ValidateFileSystemURL(request_id, url))
     return;
   if (!security_policy_->CanReadFileSystemFile(process_id_, url)) {
     Send(new FileSystemMsg_DidFail(request_id,
-                                   base::PLATFORM_FILE_ERROR_SECURITY));
+                                   base::File::FILE_ERROR_SECURITY));
     return;
   }
 
   operations_[request_id] = operation_runner()->GetMetadata(
       url, base::Bind(&FileAPIMessageFilter::DidGetMetadata, this, request_id));
 }
 
 void FileAPIMessageFilter::OnCreate(
     int request_id, const GURL& path, bool exclusive,
     bool is_directory, bool recursive) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   FileSystemURL url(context_->CrackURL(path));
   if (!ValidateFileSystemURL(request_id, url))
     return;
   if (!security_policy_->CanCreateFileSystemFile(process_id_, url)) {
     Send(new FileSystemMsg_DidFail(request_id,
-                                   base::PLATFORM_FILE_ERROR_SECURITY));
+                                   base::File::FILE_ERROR_SECURITY));
     return;
   }
 
   if (is_directory) {
     operations_[request_id] = operation_runner()->CreateDirectory(
         url, exclusive, recursive,
         base::Bind(&FileAPIMessageFilter::DidFinish, this, request_id));
   } else {
     operations_[request_id] = operation_runner()->CreateFile(
         url, exclusive,
         base::Bind(&FileAPIMessageFilter::DidFinish, this, request_id));
   }
 }
 
 void FileAPIMessageFilter::OnExists(
     int request_id, const GURL& path, bool is_directory) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   FileSystemURL url(context_->CrackURL(path));
   if (!ValidateFileSystemURL(request_id, url))
     return;
   if (!security_policy_->CanReadFileSystemFile(process_id_, url)) {
     Send(new FileSystemMsg_DidFail(request_id,
-                                   base::PLATFORM_FILE_ERROR_SECURITY));
+                                   base::File::FILE_ERROR_SECURITY));
     return;
   }
 
   if (is_directory) {
     operations_[request_id] = operation_runner()->DirectoryExists(
         url,
         base::Bind(&FileAPIMessageFilter::DidFinish, this, request_id));
   } else {
     operations_[request_id] = operation_runner()->FileExists(
         url,
         base::Bind(&FileAPIMessageFilter::DidFinish, this, request_id));
   }
 }
 
 void FileAPIMessageFilter::OnReadDirectory(
     int request_id, const GURL& path) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   FileSystemURL url(context_->CrackURL(path));
   if (!ValidateFileSystemURL(request_id, url))
     return;
   if (!security_policy_->CanReadFileSystemFile(process_id_, url)) {
     Send(new FileSystemMsg_DidFail(request_id,
-                                   base::PLATFORM_FILE_ERROR_SECURITY));
+                                   base::File::FILE_ERROR_SECURITY));
     return;
   }
 
   operations_[request_id] = operation_runner()->ReadDirectory(
       url, base::Bind(&FileAPIMessageFilter::DidReadDirectory,
                       this, request_id));
 }
 
 void FileAPIMessageFilter::OnWrite(
     int request_id,
     const GURL& path,
     const std::string& blob_uuid,
     int64 offset) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   if (!request_context_) {
     // We can't write w/o a request context, trying to do so will crash.
     NOTREACHED();
     return;
   }
 
   FileSystemURL url(context_->CrackURL(path));
   if (!ValidateFileSystemURL(request_id, url))
     return;
   if (!security_policy_->CanWriteFileSystemFile(process_id_, url)) {
     Send(new FileSystemMsg_DidFail(request_id,
-                                   base::PLATFORM_FILE_ERROR_SECURITY));
+                                   base::File::FILE_ERROR_SECURITY));
     return;
   }
 
   scoped_ptr<webkit_blob::BlobDataHandle> blob =
       blob_storage_context_->context()->GetBlobDataFromUUID(blob_uuid);
 
   operations_[request_id] = operation_runner()->Write(
       request_context_, url, blob.Pass(), offset,
       base::Bind(&FileAPIMessageFilter::DidWrite, this, request_id));
 }
 
 void FileAPIMessageFilter::OnTruncate(
     int request_id,
     const GURL& path,
     int64 length) {
   FileSystemURL url(context_->CrackURL(path));
   if (!ValidateFileSystemURL(request_id, url))
     return;
   if (!security_policy_->CanWriteFileSystemFile(process_id_, url)) {
     Send(new FileSystemMsg_DidFail(request_id,
-                                   base::PLATFORM_FILE_ERROR_SECURITY));
+                                   base::File::FILE_ERROR_SECURITY));
     return;
   }
 
   operations_[request_id] = operation_runner()->Truncate(
       url, length,
       base::Bind(&FileAPIMessageFilter::DidFinish, this, request_id));
 }
 
 void FileAPIMessageFilter::OnTouchFile(
     int request_id,
     const GURL& path,
     const base::Time& last_access_time,
     const base::Time& last_modified_time) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   FileSystemURL url(context_->CrackURL(path));
   if (!ValidateFileSystemURL(request_id, url))
     return;
   if (!security_policy_->CanCreateFileSystemFile(process_id_, url)) {
     Send(new FileSystemMsg_DidFail(request_id,
-                                   base::PLATFORM_FILE_ERROR_SECURITY));
+                                   base::File::FILE_ERROR_SECURITY));
     return;
   }
 
   operations_[request_id] = operation_runner()->TouchFile(
       url, last_access_time, last_modified_time,
       base::Bind(&FileAPIMessageFilter::DidFinish, this, request_id));
 }
 
 void FileAPIMessageFilter::OnCancel(
     int request_id,
     int request_id_to_cancel) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
   OperationsMap::iterator found = operations_.find(request_id_to_cancel);
   if (found != operations_.end()) {
     // The cancel will eventually send both the write failure and the cancel
     // success.
     operation_runner()->Cancel(
         found->second,
         base::Bind(&FileAPIMessageFilter::DidFinish, this, request_id));
   } else {
     // The write already finished; report that we failed to stop it.
     Send(new FileSystemMsg_DidFail(
-        request_id, base::PLATFORM_FILE_ERROR_INVALID_OPERATION));
+        request_id, base::File::FILE_ERROR_INVALID_OPERATION));
   }
 }
 
 void FileAPIMessageFilter::OnSyncGetPlatformPath(
     const GURL& path, base::FilePath* platform_path) {
   SyncGetPlatformPath(context_, process_id_, path, platform_path);
 }
 
 void FileAPIMessageFilter::OnCreateSnapshotFile(
     int request_id, const GURL& path) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   FileSystemURL url(context_->CrackURL(path));
 
   // Make sure if this file can be read by the renderer as this is
   // called when the renderer is about to create a new File object
   // (for reading the file).
   if (!ValidateFileSystemURL(request_id, url))
     return;
   if (!security_policy_->CanReadFileSystemFile(process_id_, url)) {
     Send(new FileSystemMsg_DidFail(request_id,
-                                   base::PLATFORM_FILE_ERROR_SECURITY));
+                                   base::File::FILE_ERROR_SECURITY));
     return;
   }
 
   operations_[request_id] = operation_runner()->CreateSnapshotFile(
       url,
       base::Bind(&FileAPIMessageFilter::DidCreateSnapshot,
                  this, request_id, url));
 }
 
 void FileAPIMessageFilter::OnDidReceiveSnapshotFile(int request_id) {
@@ skipping 172 matching lines @@
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
   if (!GetStreamForURL(url).get())
     return;
 
   stream_context_->registry()->UnregisterStream(url);
   stream_urls_.erase(url.spec());
 }
 
 void FileAPIMessageFilter::DidFinish(int request_id,
-                                     base::PlatformFileError result) {
-  if (result == base::PLATFORM_FILE_OK)
+                                     base::File::Error result) {
+  if (result == base::File::FILE_OK)
     Send(new FileSystemMsg_DidSucceed(request_id));
   else
     Send(new FileSystemMsg_DidFail(request_id, result));
   operations_.erase(request_id);
 }
 
 void FileAPIMessageFilter::DidGetMetadata(
     int request_id,
-    base::PlatformFileError result,
-    const base::PlatformFileInfo& info) {
-  if (result == base::PLATFORM_FILE_OK)
+    base::File::Error result,
+    const base::File::Info& info) {
+  if (result == base::File::FILE_OK)
     Send(new FileSystemMsg_DidReadMetadata(request_id, info));
   else
     Send(new FileSystemMsg_DidFail(request_id, result));
   operations_.erase(request_id);
 }
 
 void FileAPIMessageFilter::DidReadDirectory(
     int request_id,
-    base::PlatformFileError result,
+    base::File::Error result,
     const std::vector<fileapi::DirectoryEntry>& entries,
     bool has_more) {
-  if (result == base::PLATFORM_FILE_OK)
+  if (result == base::File::FILE_OK)
     Send(new FileSystemMsg_DidReadDirectory(request_id, entries, has_more));
   else
     Send(new FileSystemMsg_DidFail(request_id, result));
   operations_.erase(request_id);
 }
 
 void FileAPIMessageFilter::DidWrite(int request_id,
-                                    base::PlatformFileError result,
+                                    base::File::Error result,
                                     int64 bytes,
                                     bool complete) {
-  if (result == base::PLATFORM_FILE_OK) {
+  if (result == base::File::FILE_OK) {
     Send(new FileSystemMsg_DidWrite(request_id, bytes, complete));
     if (complete)
       operations_.erase(request_id);
   } else {
     Send(new FileSystemMsg_DidFail(request_id, result));
     operations_.erase(request_id);
   }
 }
 
 void FileAPIMessageFilter::DidOpenFileSystem(int request_id,
                                              const GURL& root,
                                              const std::string& filesystem_name,
-                                             base::PlatformFileError result) {
+                                             base::File::Error result) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
-  if (result == base::PLATFORM_FILE_OK) {
+  if (result == base::File::FILE_OK) {
     DCHECK(root.is_valid());
     Send(new FileSystemMsg_DidOpenFileSystem(
         request_id, filesystem_name, root));
   } else {
     Send(new FileSystemMsg_DidFail(request_id, result));
   }
   // For OpenFileSystem we do not create a new operation, so no unregister here.
 }
 
 void FileAPIMessageFilter::DidResolveURL(int request_id,
-                                         base::PlatformFileError result,
+                                         base::File::Error result,
                                          const fileapi::FileSystemInfo& info,
                                          const base::FilePath& file_path,
                                          bool is_directory) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
-  if (result == base::PLATFORM_FILE_OK) {
+  if (result == base::File::FILE_OK) {
     DCHECK(info.root_url.is_valid());
     Send(new FileSystemMsg_DidResolveURL(
         request_id, info, file_path, is_directory));
   } else {
     Send(new FileSystemMsg_DidFail(request_id, result));
   }
   // For ResolveURL we do not create a new operation, so no unregister here.
 }
 
 void FileAPIMessageFilter::DidDeleteFileSystem(
     int request_id,
-    base::PlatformFileError result) {
-  if (result == base::PLATFORM_FILE_OK)
+    base::File::Error result) {
+  if (result == base::File::FILE_OK)
     Send(new FileSystemMsg_DidSucceed(request_id));
   else
     Send(new FileSystemMsg_DidFail(request_id, result));
   // For DeleteFileSystem we do not create a new operation,
   // so no unregister here.
 }
 
 void FileAPIMessageFilter::DidCreateSnapshot(
     int request_id,
     const fileapi::FileSystemURL& url,
-    base::PlatformFileError result,
-    const base::PlatformFileInfo& info,
+    base::File::Error result,
+    const base::File::Info& info,
     const base::FilePath& platform_path,
     const scoped_refptr<webkit_blob::ShareableFileReference>& /* unused */) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   operations_.erase(request_id);
 
-  if (result != base::PLATFORM_FILE_OK) {
+  if (result != base::File::FILE_OK) {
     Send(new FileSystemMsg_DidFail(request_id, result));
     return;
   }
 
   // TODO(tommycli): This allows streaming blobs to use a 'fake' snapshot file
   // with an empty path. We want to eventually have explicit plumbing for
   // the creation of Blobs without snapshot files, probably called something
   // like GetMetadataForStreaming.
   if (platform_path.empty()) {
     Send(new FileSystemMsg_DidCreateSnapshotFile(request_id, info,
@@ skipping 32 matching lines @@
 
   // Return the file info and platform_path.
   Send(new FileSystemMsg_DidCreateSnapshotFile(
       request_id, info, platform_path));
 }
 
 bool FileAPIMessageFilter::ValidateFileSystemURL(
     int request_id, const fileapi::FileSystemURL& url) {
   if (!FileSystemURLIsValid(context_, url)) {
     Send(new FileSystemMsg_DidFail(request_id,
-                                   base::PLATFORM_FILE_ERROR_INVALID_URL));
+                                   base::File::FILE_ERROR_INVALID_URL));
     return false;
   }
 
   // Deny access to files in PluginPrivate FileSystem from JavaScript.
   // TODO(nhiroki): Move this filter somewhere else since this is not for
   // validation.
   if (url.type() == fileapi::kFileSystemTypePluginPrivate) {
     Send(new FileSystemMsg_DidFail(request_id,
-                                   base::PLATFORM_FILE_ERROR_SECURITY));
+                                   base::File::FILE_ERROR_SECURITY));
     return false;
   }
 
   return true;
 }
 
 scoped_refptr<Stream> FileAPIMessageFilter::GetStreamForURL(const GURL& url) {
   return stream_context_->registry()->GetStream(url);
 }
 
 }  // namespace content