Convert Media Galleries to use base::File

content/child/fileapi/webfilesystem_impl.cc

 // Copyright 2013 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/child/fileapi/webfilesystem_impl.h"
 
 #include "base/bind.h"
 #include "base/lazy_instance.h"
 #include "base/logging.h"
 #include "base/message_loop/message_loop_proxy.h"
@@ skipping 153 matching lines @@
   CallbackFileSystemCallbacks(
       thread_id, callbacks_id, waitable_results,
       &WebFileSystemCallbacks::didResolveURL,
       MakeTuple(base::UTF8ToUTF16(info.name), info.root_url,
                 static_cast<blink::WebFileSystemType>(info.mount_type),
                 normalized_path.AsUTF16Unsafe(), is_directory));
 }
 
 void StatusCallbackAdapter(int thread_id, int callbacks_id,
                            WaitableCallbackResults* waitable_results,
-                           base::PlatformFileError error) {
-  if (error == base::PLATFORM_FILE_OK) {
+                           base::File::Error error) {
+  if (error == base::File::FILE_OK) {
     CallbackFileSystemCallbacks(
         thread_id, callbacks_id, waitable_results,
         &WebFileSystemCallbacks::didSucceed, MakeTuple());
   } else {
     CallbackFileSystemCallbacks(
         thread_id, callbacks_id, waitable_results,
         &WebFileSystemCallbacks::didFail,
-        MakeTuple(fileapi::PlatformFileErrorToWebFileError(error)));
+        MakeTuple(fileapi::FileErrorToWebFileError(error)));
   }
 }
 
 void ReadMetadataCallbackAdapter(int thread_id, int callbacks_id,
                                  WaitableCallbackResults* waitable_results,
-                                 const base::PlatformFileInfo& file_info) {
+                                 const base::File::Info& file_info) {
   WebFileInfo web_file_info;
-  webkit_glue::PlatformFileInfoToWebFileInfo(file_info, &web_file_info);
+  webkit_glue::FileInfoToWebFileInfo(file_info, &web_file_info);
   CallbackFileSystemCallbacks(
       thread_id, callbacks_id, waitable_results,
       &WebFileSystemCallbacks::didReadMetadata,
       MakeTuple(web_file_info));
 }
 
 void ReadDirectoryCallbackAdapater(
     int thread_id, int callbacks_id, WaitableCallbackResults* waitable_results,
     const std::vector<fileapi::DirectoryEntry>& entries,
     bool has_more) {
   WebVector<WebFileSystemEntry> file_system_entries(entries.size());
   for (size_t i = 0; i < entries.size(); i++) {
     file_system_entries[i].name =
         base::FilePath(entries[i].name).AsUTF16Unsafe();
     file_system_entries[i].isDirectory = entries[i].is_directory;
   }
   CallbackFileSystemCallbacks(
       thread_id, callbacks_id, waitable_results,
       &WebFileSystemCallbacks::didReadDirectory,
       MakeTuple(file_system_entries, has_more));
 }
 
 void DidCreateFileWriter(
     int callbacks_id,
     const GURL& path,
     blink::WebFileWriterClient* client,
     base::MessageLoopProxy* main_thread_loop,
-    const base::PlatformFileInfo& file_info) {
+    const base::File::Info& file_info) {
   WebFileSystemImpl* filesystem =
       WebFileSystemImpl::ThreadSpecificInstance(NULL);
   if (!filesystem)
     return;
 
   WebFileSystemCallbacks callbacks =
       filesystem->GetAndUnregisterCallbacks(callbacks_id);
 
   if (file_info.is_directory || file_info.size < 0) {
     callbacks.didFail(blink::WebFileErrorInvalidState);
     return;
   }
   WebFileWriterImpl::Type type =
       callbacks.shouldBlockUntilCompletion() ?
           WebFileWriterImpl::TYPE_SYNC : WebFileWriterImpl::TYPE_ASYNC;
   callbacks.didCreateFileWriter(
       new WebFileWriterImpl(path, client, type, main_thread_loop),
       file_info.size);
 }
 
 void CreateFileWriterCallbackAdapter(
     int thread_id, int callbacks_id,
     WaitableCallbackResults* waitable_results,
     base::MessageLoopProxy* main_thread_loop,
     const GURL& path,
     blink::WebFileWriterClient* client,
-    const base::PlatformFileInfo& file_info) {
+    const base::File::Info& file_info) {
   DispatchResultsClosure(
       thread_id, callbacks_id, waitable_results,
       base::Bind(&DidCreateFileWriter, callbacks_id, path, client,
                  make_scoped_refptr(main_thread_loop), file_info));
 }
 
 void DidCreateSnapshotFile(
     int callbacks_id,
     base::MessageLoopProxy* main_thread_loop,
-    const base::PlatformFileInfo& file_info,
+    const base::File::Info& file_info,
     const base::FilePath& platform_path,
     int request_id) {
   WebFileSystemImpl* filesystem =
       WebFileSystemImpl::ThreadSpecificInstance(NULL);
   if (!filesystem)
     return;
 
   WebFileSystemCallbacks callbacks =
       filesystem->GetAndUnregisterCallbacks(callbacks_id);
 
   WebFileInfo web_file_info;
-  webkit_glue::PlatformFileInfoToWebFileInfo(file_info, &web_file_info);
+  webkit_glue::FileInfoToWebFileInfo(file_info, &web_file_info);
   web_file_info.platformPath = platform_path.AsUTF16Unsafe();
   callbacks.didCreateSnapshotFile(web_file_info);
 
   // TODO(michaeln,kinuko): Use ThreadSafeSender when Blob becomes
   // non-bridge model.
   main_thread_loop->PostTask(
       FROM_HERE, base::Bind(&DidReceiveSnapshotFile, request_id));
 }
 
 void CreateSnapshotFileCallbackAdapter(
     int thread_id, int callbacks_id,
     WaitableCallbackResults* waitable_results,
     base::MessageLoopProxy* main_thread_loop,
-    const base::PlatformFileInfo& file_info,
+    const base::File::Info& file_info,
     const base::FilePath& platform_path,
     int request_id) {
   DispatchResultsClosure(
       thread_id, callbacks_id, waitable_results,
       base::Bind(&DidCreateSnapshotFile, callbacks_id,
                  make_scoped_refptr(main_thread_loop),
                  file_info, platform_path, request_id));
 }
 
 }  // namespace
@@ skipping 312 matching lines @@
     int callbacks_id) {
   DCHECK(CalledOnValidThread());
   CallbacksMap::iterator found = callbacks_.find(callbacks_id);
   DCHECK(found != callbacks_.end());
   WebFileSystemCallbacks callbacks = found->second;
   callbacks_.erase(found);
   return callbacks;
 }
 
 }  // namespace content