Convert Media Galleries to use base::File

content/child/fileapi/webfilewriter_base.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/webfilewriter_base.h"
 
 #include "base/logging.h"
 #include "third_party/WebKit/public/platform/WebFileError.h"
 #include "third_party/WebKit/public/platform/WebFileWriterClient.h"
 #include "third_party/WebKit/public/platform/WebURL.h"
 #include "webkit/common/fileapi/file_system_util.h"
 
-using fileapi::PlatformFileErrorToWebFileError;
+using fileapi::FileErrorToWebFileError;
 
 namespace content {
 
 WebFileWriterBase::WebFileWriterBase(const GURL& path,
                                      blink::WebFileWriterClient* client)
     : path_(path),
       client_(client),
       operation_(kOperationNone),
       cancel_state_(kCancelNotInProgress) {}
 
@@ skipping 32 matching lines @@
 void WebFileWriterBase::cancel() {
   // Check for the cancel passing the previous operation's return in-flight.
   if (kOperationWrite != operation_ && kOperationTruncate != operation_)
     return;
   if (kCancelNotInProgress != cancel_state_)
     return;
   cancel_state_ = kCancelSent;
   DoCancel();
 }
 
-void WebFileWriterBase::DidFinish(base::PlatformFileError error_code) {
-  if (error_code == base::PLATFORM_FILE_OK)
+void WebFileWriterBase::DidFinish(base::File::Error error_code) {
+  if (error_code == base::File::FILE_OK)
     DidSucceed();
   else
     DidFail(error_code);
 }
 
 void WebFileWriterBase::DidWrite(int64 bytes, bool complete) {
   DCHECK(kOperationWrite == operation_);
   switch (cancel_state_) {
     case kCancelNotInProgress:
       if (complete)
@@ skipping 32 matching lines @@
       break;
     case kCancelReceivedWriteResponse:
       // This is the success of the cancel operation.
       FinishCancel();
       break;
     default:
       NOTREACHED();
   }
 }
 
-void WebFileWriterBase::DidFail(base::PlatformFileError error_code) {
+void WebFileWriterBase::DidFail(base::File::Error error_code) {
   DCHECK(kOperationNone != operation_);
   switch (cancel_state_) {
     case kCancelNotInProgress:
       // A write or truncate failed.
       operation_ = kOperationNone;
-      client_->didFail(PlatformFileErrorToWebFileError(error_code));
+      client_->didFail(FileErrorToWebFileError(error_code));
       break;
     case kCancelSent:
       // This is the failure of a write or truncate; the next message should be
       // the result of the cancel.  We don't assume that it'll be a success, as
       // the write/truncate could have failed for other reasons.
       cancel_state_ = kCancelReceivedWriteResponse;
       break;
     case kCancelReceivedWriteResponse:
       // The cancel reported failure, meaning that the write or truncate
       // finished before the cancel got there.  But we suppressed the
       // write/truncate's response, and will now report that it was cancelled.
       FinishCancel();
       break;
     default:
       NOTREACHED();
   }
 }
 
 void WebFileWriterBase::FinishCancel() {
   DCHECK(kCancelReceivedWriteResponse == cancel_state_);
   DCHECK(kOperationNone != operation_);
   cancel_state_ = kCancelNotInProgress;
   operation_ = kOperationNone;
   client_->didFail(blink::WebFileErrorAbort);
 }
 
 }  // namespace content