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

media/capture/video/fake_video_capture_device.cc

 // Copyright (c) 2012 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/fake_video_capture_device.h"
 
 #include <stddef.h>
 #include <algorithm>
 #include <utility>
 
@@ skipping 169 matching lines @@
   const size_t frame_size = capture_format_.ImageAllocationSize();
   memset(fake_frame_.get(), 0, frame_size);
 
   DrawPacman(false /* use_argb */, fake_frame_.get(), elapsed_time_,
              fake_capture_rate_, capture_format_.frame_size);
 
   // Give the captured frame to the client.
   base::TimeTicks now = base::TimeTicks::Now();
   if (first_ref_time_.is_null())
     first_ref_time_ = now;
-  client_->OnIncomingCapturedData(fake_frame_.get(), frame_size,
-                                  capture_format_, 0 /* rotation */, now,
-                                  now - first_ref_time_);
+  client_->OnIncomingCapturedData(
+      fake_frame_.get(), static_cast<int>(frame_size), capture_format_,
+      0u /* rotation */, now, now - first_ref_time_);
   BeepAndScheduleNextCapture(
       expected_execution_time,
       base::Bind(&FakeVideoCaptureDevice::CaptureUsingOwnBuffers,
                  weak_factory_.GetWeakPtr()));
 }
 
 void FakeVideoCaptureDevice::CaptureUsingClientBuffers(
     base::TimeTicks expected_execution_time) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
@@ skipping 12 matching lines @@
     DrawPacman(false /* use_argb */, fake_frame_.get(), elapsed_time_,
                fake_capture_rate_, capture_format_.frame_size);
 
     // Copy data from |fake_frame_| into the reserved planes of GpuMemoryBuffer.
     size_t offset = 0;
     for (size_t i = 0; i < VideoFrame::NumPlanes(PIXEL_FORMAT_I420); ++i) {
       const size_t plane_size =
           VideoFrame::PlaneSize(PIXEL_FORMAT_I420, i,
                                 capture_format_.frame_size)
               .GetArea();
-      memcpy(capture_buffer->data(i), fake_frame_.get() + offset, plane_size);
+      memcpy(capture_buffer->data(i), fake_frame_.get() + offset,
+             static_cast<int>(plane_size));
       offset += plane_size;
     }
   } else {
     DCHECK_EQ(capture_format_.pixel_storage, PIXEL_STORAGE_CPU);
     DCHECK_EQ(capture_format_.pixel_format, PIXEL_FORMAT_ARGB);
     uint8_t* data_ptr = static_cast<uint8_t*>(capture_buffer->data());
     memset(data_ptr, 0, capture_buffer->mapped_size());
     DrawPacman(true /* use_argb */, data_ptr, elapsed_time_, fake_capture_rate_,
                capture_format_.frame_size);
   }
@@ skipping 32 matching lines @@
   // Don't accumulate any debt if we are lagging behind - just post the next
   // frame immediately and continue as normal.
   const base::TimeTicks next_execution_time =
       std::max(current_time, expected_execution_time + frame_interval);
   const base::TimeDelta delay = next_execution_time - current_time;
   base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
       FROM_HERE, base::Bind(next_capture, next_execution_time), delay);
 }
 
 }  // namespace media