Media: Remove uses of PlatformFile

media/video/capture/file_video_capture_device.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 "media/video/capture/file_video_capture_device.h"
 
 #include <string>
 
 #include "base/bind.h"
 #include "base/command_line.h"
@@ skipping 92 matching lines @@
   }
   // Last video format semantic correctness check before sending it back.
   CHECK(video_format->IsValid());
 }
 
 // Reads and parses the header of a Y4M |file|, returning the collected pixel
 // format in |video_format|. Returns the index of the first byte of the first
 // video frame.
 // Restrictions: Only trivial per-frame headers are supported.
 int64 ParseFileAndExtractVideoFormat(
-    const base::PlatformFile& file,
+    base::File* file,
     media::VideoCaptureFormat* video_format) {
   std::string header(kY4MHeaderMaxSize, 0);
-  base::ReadPlatformFile(file, 0, &header[0], kY4MHeaderMaxSize - 1);
+  file->Read(0, &header[0], kY4MHeaderMaxSize - 1);
 
   size_t header_end = header.find(kY4MSimpleFrameDelimiter);
   CHECK_NE(header_end, header.npos);
 
   ParseY4MTags(header, video_format);
   return header_end + kY4MSimpleFrameDelimiterSize;
 }
 
 // Opens a given file for reading, and returns the file to the caller, who is
 // responsible for closing it.
-base::PlatformFile OpenFileForRead(const base::FilePath& file_path) {
-  base::PlatformFileError file_error;
-  base::PlatformFile file = base::CreatePlatformFile(
-      file_path,
-      base::PLATFORM_FILE_OPEN | base::PLATFORM_FILE_READ,
-      NULL,
-      &file_error);
-  CHECK_EQ(file_error, base::PLATFORM_FILE_OK);
-  return file;
+base::File OpenFileForRead(const base::FilePath& file_path) {
+  base::File file(file_path, base::File::FLAG_OPEN | base::File::FLAG_READ);
+  CHECK(file.IsValid());
+  return file.Pass();
 }
 
 // Inspects the command line and retrieves the file path parameter.
 base::FilePath GetFilePathFromCommandLine() {
   base::FilePath command_line_file_path =
       CommandLine::ForCurrentProcess()->GetSwitchValuePath(
           switches::kUseFileForFakeVideoCapture);
   CHECK(!command_line_file_path.empty());
   return command_line_file_path;
 }
 
 void FileVideoCaptureDevice::GetDeviceNames(Names* const device_names) {
   DCHECK(device_names->empty());
   base::FilePath command_line_file_path = GetFilePathFromCommandLine();
 #if defined(OS_WIN)
   device_names->push_back(
       Name(base::SysWideToUTF8(command_line_file_path.value()),
            kFileVideoCaptureDeviceName));
 #else
   device_names->push_back(Name(command_line_file_path.value(),
                                kFileVideoCaptureDeviceName));
 #endif  // OS_WIN
 }
 
 void FileVideoCaptureDevice::GetDeviceSupportedFormats(
     const Name& device,
     VideoCaptureFormats* supported_formats) {
-  base::PlatformFile file = OpenFileForRead(GetFilePathFromCommandLine());
+  base::File file = OpenFileForRead(GetFilePathFromCommandLine());
   VideoCaptureFormat capture_format;
-  ParseFileAndExtractVideoFormat(file, &capture_format);
+  ParseFileAndExtractVideoFormat(&file, &capture_format);
   supported_formats->push_back(capture_format);
-
-  CHECK(base::ClosePlatformFile(file));
 }
 
 VideoCaptureDevice* FileVideoCaptureDevice::Create(const Name& device_name) {
 #if defined(OS_WIN)
   return new FileVideoCaptureDevice(
       base::FilePath(base::SysUTF8ToWide(device_name.name())));
 #else
   return new FileVideoCaptureDevice(base::FilePath(device_name.name()));
 #endif  // OS_WIN
 }
 
 FileVideoCaptureDevice::FileVideoCaptureDevice(const base::FilePath& file_path)
     : capture_thread_("CaptureThread"),
       file_path_(file_path),
-      file_(base::kInvalidPlatformFileValue),
       frame_size_(0),
       current_byte_index_(0),
       first_frame_byte_index_(0) {}
 
 FileVideoCaptureDevice::~FileVideoCaptureDevice() {
   DCHECK(thread_checker_.CalledOnValidThread());
   // Check if the thread is running.
   // This means that the device have not been DeAllocated properly.
   CHECK(!capture_thread_.IsRunning());
 }
@@ skipping 31 matching lines @@
 }
 
 void FileVideoCaptureDevice::OnAllocateAndStart(
     const VideoCaptureParams& params,
     scoped_ptr<VideoCaptureDevice::Client> client) {
   DCHECK_EQ(capture_thread_.message_loop(), base::MessageLoop::current());
 
   client_ = client.Pass();
 
   // Open the file and parse the header. Get frame size and format.
-  DCHECK_EQ(file_, base::kInvalidPlatformFileValue);
+  DCHECK(file_.IsValid());
   file_ = OpenFileForRead(file_path_);
   first_frame_byte_index_ =
-      ParseFileAndExtractVideoFormat(file_, &capture_format_);
+      ParseFileAndExtractVideoFormat(&file_, &capture_format_);
   current_byte_index_ = first_frame_byte_index_;
   DVLOG(1) << "Opened video file " << capture_format_.frame_size.ToString()
            << ", fps: " << capture_format_.frame_rate;
 
   frame_size_ = CalculateFrameSize();
   video_frame_.reset(new uint8[frame_size_]);
 
   capture_thread_.message_loop()->PostTask(
       FROM_HERE,
       base::Bind(&FileVideoCaptureDevice::OnCaptureTask,
                  base::Unretained(this)));
 }
 
 void FileVideoCaptureDevice::OnStopAndDeAllocate() {
   DCHECK_EQ(capture_thread_.message_loop(), base::MessageLoop::current());
-  CHECK(base::ClosePlatformFile(file_));
+  file_.Close();
   client_.reset();
   current_byte_index_ = 0;
   first_frame_byte_index_ = 0;
   frame_size_ = 0;
   video_frame_.reset();
 }
 
 void FileVideoCaptureDevice::OnCaptureTask() {
   DCHECK_EQ(capture_thread_.message_loop(), base::MessageLoop::current());
   if (!client_)
     return;
-  int result =
-      base::ReadPlatformFile(file_,
-                             current_byte_index_,
-                             reinterpret_cast<char*>(video_frame_.get()),
-                             frame_size_);
+  int result = file_.Read(current_byte_index_,
+                          reinterpret_cast<char*>(video_frame_.get()),
+                          frame_size_);
 
-  // If we passed EOF to PlatformFile, it will return 0 read characters. In that
+  // If we passed EOF to base::File, it will return 0 read characters. In that
   // case, reset the pointer and read again.
   if (result != frame_size_) {
     CHECK_EQ(result, 0);
     current_byte_index_ = first_frame_byte_index_;
-    CHECK_EQ(base::ReadPlatformFile(file_,
-                                    current_byte_index_,
-                                    reinterpret_cast<char*>(video_frame_.get()),
-                                    frame_size_),
+    CHECK_EQ(file_.Read(current_byte_index_,
+                        reinterpret_cast<char*>(video_frame_.get()),
+                        frame_size_),
              frame_size_);
   } else {
     current_byte_index_ += frame_size_ + kY4MSimpleFrameDelimiterSize;
   }
 
   // Give the captured frame to the client.
   client_->OnIncomingCapturedFrame(video_frame_.get(),
                                    frame_size_,
                                    base::TimeTicks::Now(),
                                    0,
                                    capture_format_);
   // Reschedule next CaptureTask.
   base::MessageLoop::current()->PostDelayedTask(
       FROM_HERE,
       base::Bind(&FileVideoCaptureDevice::OnCaptureTask,
                  base::Unretained(this)),
       base::TimeDelta::FromSeconds(1) / capture_format_.frame_rate);
 }
 
 }  // namespace media