Revert of Re-Reland: Make media/capture gn and gyps produce components

media/capture/video/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/capture/video/file_video_capture_device.h"
 
 #include <stddef.h>
 #include <utility>
 
 #include "base/bind.h"
@@ skipping 161 matching lines @@
 bool Y4mFileParser::Initialize(media::VideoCaptureFormat* capture_format) {
   file_.reset(new base::File(file_path_,
                              base::File::FLAG_OPEN | base::File::FLAG_READ));
   if (!file_->IsValid()) {
     DLOG(ERROR) << file_path_.value() << ", error: "
                 << base::File::ErrorToString(file_->error_details());
     return false;
   }
 
   std::string header(kY4MHeaderMaxSize, '\0');
-  file_->Read(0, &header[0], static_cast<int>(header.size()));
+  file_->Read(0, &header[0], header.size());
   const size_t header_end = header.find(kY4MSimpleFrameDelimiter);
   CHECK_NE(header_end, header.npos);
 
   ParseY4MTags(header, capture_format);
   first_frame_byte_index_ = header_end + kY4MSimpleFrameDelimiterSize;
   current_byte_index_ = first_frame_byte_index_;
-  frame_size_ = static_cast<int>(capture_format->ImageAllocationSize());
+  frame_size_ = capture_format->ImageAllocationSize();
   return true;
 }
 
 const uint8_t* Y4mFileParser::GetNextFrame(int* frame_size) {
   if (!video_frame_)
     video_frame_.reset(new uint8_t[frame_size_]);
   int result =
       file_->Read(current_byte_index_,
                   reinterpret_cast<char*>(video_frame_.get()), frame_size_);
 
@@ skipping 23 matching lines @@
 
   if (!mapped_file_->Initialize(file_path_) || !mapped_file_->IsValid()) {
     LOG(ERROR) << "File memory map error: " << file_path_.value();
     return false;
   }
 
   JpegParseResult result;
   if (!ParseJpegStream(mapped_file_->data(), mapped_file_->length(), &result))
     return false;
 
-  frame_size_ = static_cast<int>(result.image_size);
+  frame_size_ = result.image_size;
   if (frame_size_ > static_cast<int>(mapped_file_->length())) {
     LOG(ERROR) << "File is incomplete";
     return false;
   }
 
   VideoCaptureFormat format;
   format.pixel_format = media::PIXEL_FORMAT_MJPEG;
   format.frame_size.set_width(result.frame_header.visible_width);
   format.frame_size.set_height(result.frame_header.visible_height);
   format.frame_rate = kMJpegFrameRate;
   if (!format.IsValid())
     return false;
   *capture_format = format;
   return true;
 }
 
 const uint8_t* MjpegFileParser::GetNextFrame(int* frame_size) {
   const uint8_t* buf_ptr = mapped_file_->data() + current_byte_index_;
 
   JpegParseResult result;
   if (!ParseJpegStream(buf_ptr, mapped_file_->length() - current_byte_index_,
                        &result)) {
     return nullptr;
   }
-  *frame_size = frame_size_ = static_cast<int>(result.image_size);
+  *frame_size = frame_size_ = result.image_size;
   current_byte_index_ += frame_size_;
   // Reset the pointer to play repeatedly.
   if (current_byte_index_ >= mapped_file_->length())
     current_byte_index_ = first_frame_byte_index_;
   return buf_ptr;
 }
 
 // static
 bool FileVideoCaptureDevice::GetVideoCaptureFormat(
     const base::FilePath& file_path,
@@ skipping 116 matching lines @@
     if (next_frame_time_ < current_time)
       next_frame_time_ = current_time;
   }
   base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
       FROM_HERE, base::Bind(&FileVideoCaptureDevice::OnCaptureTask,
                             base::Unretained(this)),
       next_frame_time_ - current_time);
 }
 
 }  // namespace media