Convert Media Galleries to use base::File

chrome/browser/chromeos/drive/webkit_file_stream_writer_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 "chrome/browser/chromeos/drive/webkit_file_stream_writer_impl.h"
 
 #include "base/bind.h"
 #include "base/callback_helpers.h"
 #include "chrome/browser/chromeos/drive/file_system_util.h"
 #include "chrome/browser/chromeos/drive/fileapi_worker.h"
@@ skipping 18 matching lines @@
 
   BrowserThread::PostTask(
       BrowserThread::UI,
       FROM_HERE,
       base::Bind(
           &fileapi_internal::RunFileSystemCallback,
           file_system_getter,
           base::Bind(&fileapi_internal::CreateWritableSnapshotFile,
                      drive_path, google_apis::CreateRelayCallback(callback)),
           google_apis::CreateRelayCallback(base::Bind(
-              callback, base::PLATFORM_FILE_ERROR_FAILED, base::FilePath(),
+              callback, base::File::FILE_ERROR_FAILED, base::FilePath(),
               base::Closure()))));
 }
 
 }  // namespace
 
 WebkitFileStreamWriterImpl::WebkitFileStreamWriterImpl(
     const FileSystemGetter& file_system_getter,
     base::TaskRunner* file_task_runner,
     const base::FilePath& file_path,
     int64 offset)
@@ skipping 75 matching lines @@
 
   // Here is the case Flush() is called before any Write() invocation.
   // Do nothing.
   // Synchronization to the remote server is not done until the file is closed.
   return net::OK;
 }
 
 void WebkitFileStreamWriterImpl::WriteAfterCreateWritableSnapshotFile(
     net::IOBuffer* buf,
     int buf_len,
-    base::PlatformFileError open_result,
+    base::File::Error open_result,
     const base::FilePath& local_path,
     const base::Closure& close_callback_on_ui_thread) {
   DCHECK(!local_file_writer_);
 
   if (!pending_cancel_callback_.is_null()) {
     DCHECK(pending_write_callback_.is_null());
     // Cancel() is called during the creation of the snapshot file.
     // Don't write to the file.
-    if (open_result == base::PLATFORM_FILE_OK) {
+    if (open_result == base::File::FILE_OK) {
       // Here the file is internally created. To revert the operation, close
       // the file.
       DCHECK(!close_callback_on_ui_thread.is_null());
       BrowserThread::PostTask(BrowserThread::UI,
                               FROM_HERE,
                               close_callback_on_ui_thread);
     }
 
     base::ResetAndReturn(&pending_cancel_callback_).Run(net::OK);
     return;
   }
 
   DCHECK(!pending_write_callback_.is_null());
 
   const net::CompletionCallback callback =
       base::ResetAndReturn(&pending_write_callback_);
-  if (open_result != base::PLATFORM_FILE_OK) {
+  if (open_result != base::File::FILE_OK) {
     DCHECK(close_callback_on_ui_thread.is_null());
-    callback.Run(net::PlatformFileErrorToNetError(open_result));
+    callback.Run(
+        net::FileErrorToNetError(open_result));
     return;
   }
 
   // Keep |close_callback| to close the file when the stream is destructed.
   DCHECK(!close_callback_on_ui_thread.is_null());
   close_callback_on_ui_thread_ = close_callback_on_ui_thread;
   local_file_writer_.reset(fileapi::FileStreamWriter::CreateForLocalFile(
       file_task_runner_.get(), local_path, offset_));
   int result = local_file_writer_->Write(buf, buf_len, callback);
   if (result != net::ERR_IO_PENDING)
     callback.Run(result);
 }
 
 }  // namespace internal
 }  // namespace drive