Convert Media Galleries to use base::File

chrome/browser/media_galleries/fileapi/supported_image_type_validator.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/media_galleries/fileapi/supported_image_type_validator.h"
 
 #include "base/bind.h"
 #include "base/callback.h"
-#include "base/files/scoped_platform_file_closer.h"
+#include "base/files/file.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/weak_ptr.h"
 #include "base/stl_util.h"
 #include "base/threading/thread_restrictions.h"
 #include "chrome/browser/image_decoder.h"
 #include "content/public/browser/browser_thread.h"
 
 using content::BrowserThread;
 
 namespace {
 
 // Arbitrary limit to sanity check the file size.
 const int kMaxImageFileSize = 50*1014*1024;
 
 scoped_ptr<std::string> ReadOnFileThread(const base::FilePath& path) {
   base::ThreadRestrictions::AssertIOAllowed();
   scoped_ptr<std::string> result;
 
-  base::PlatformFile file = base::CreatePlatformFile(
-      path, base::PLATFORM_FILE_OPEN | base::PLATFORM_FILE_READ, NULL, NULL);
-  if (file == base::kInvalidPlatformFileValue)
+  base::File file(path, base::File::FLAG_OPEN | base::File::FLAG_READ);
+  if (!file.IsValid())
     return result.Pass();
-  base::ScopedPlatformFileCloser file_closer(&file);
 
-  base::PlatformFileInfo file_info;
-  if (!base::GetPlatformFileInfo(file, &file_info) ||
+  base::File::Info file_info;
+  if (!file.GetInfo(&file_info) ||
       file_info.size > kMaxImageFileSize) {
     return result.Pass();
   }
 
   result.reset(new std::string);
   result->resize(file_info.size);
-  if (base::ReadPlatformFile(file, 0, string_as_array(result.get()),
-                             file_info.size) != file_info.size) {
+  if (file.Read(0, string_as_array(result.get()), file_info.size) !=
+      file_info.size) {
     result.reset();
   }
 
   return result.Pass();
 }
 
 class ImageDecoderDelegateAdapter : public ImageDecoder::Delegate {
  public:
   ImageDecoderDelegateAdapter(
       scoped_ptr<std::string> data,
       const fileapi::CopyOrMoveFileValidator::ResultCallback& callback)
       : data_(data.Pass()),
         callback_(callback) {
     DCHECK(data_);
   }
 
   const std::string& data() {
     return *data_;
   }
 
   // ImageDecoder::Delegate methods.
   virtual void OnImageDecoded(const ImageDecoder* /*decoder*/,
                               const SkBitmap& /*decoded_image*/) OVERRIDE {
-    callback_.Run(base::PLATFORM_FILE_OK);
+    callback_.Run(base::File::FILE_OK);
     delete this;
   }
 
   virtual void OnDecodeImageFailed(const ImageDecoder* /*decoder*/) OVERRIDE {
-    callback_.Run(base::PLATFORM_FILE_ERROR_SECURITY);
+    callback_.Run(base::File::FILE_ERROR_SECURITY);
     delete this;
   }
 
  private:
   scoped_ptr<std::string> data_;
   fileapi::CopyOrMoveFileValidator::ResultCallback callback_;
 
   DISALLOW_COPY_AND_ASSIGN(ImageDecoderDelegateAdapter);
 };
 
@@ skipping 31 matching lines @@
 
 SupportedImageTypeValidator::SupportedImageTypeValidator(
     const base::FilePath& path)
     : path_(path),
       weak_factory_(this) {
 }
 
 void SupportedImageTypeValidator::OnFileOpen(scoped_ptr<std::string> data) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   if (!data.get()) {
-    callback_.Run(base::PLATFORM_FILE_ERROR_SECURITY);
+    callback_.Run(base::File::FILE_ERROR_SECURITY);
     return;
   }
 
   // |adapter| will delete itself after a completion message is received.
   ImageDecoderDelegateAdapter* adapter =
       new ImageDecoderDelegateAdapter(data.Pass(), callback_);
   decoder_ = new ImageDecoder(adapter, adapter->data(),
                               ImageDecoder::DEFAULT_CODEC);
   decoder_->Start(content::BrowserThread::GetMessageLoopProxyForThread(
       BrowserThread::IO));
 }