Reland [Mojo Video Capture] Simplify media::VideoCaptureDevice::Client:Buffer to a struct

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 301 matching lines @@
       expected_execution_time,
       base::Bind(&FakeVideoCaptureDevice::CaptureUsingOwnBuffers,
                  weak_factory_.GetWeakPtr()));
 }
 
 void FakeVideoCaptureDevice::CaptureUsingClientBuffers(
     base::TimeTicks expected_execution_time) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   const int arbitrary_frame_feedback_id = 0;
-  std::unique_ptr<VideoCaptureDevice::Client::Buffer> capture_buffer(
+  VideoCaptureDevice::Client::Buffer capture_buffer =
       client_->ReserveOutputBuffer(
           capture_format_.frame_size, capture_format_.pixel_format,
-          capture_format_.pixel_storage, arbitrary_frame_feedback_id));
-  DLOG_IF(ERROR, !capture_buffer) << "Couldn't allocate Capture Buffer";
-  DCHECK(capture_buffer->data()) << "Buffer has NO backing memory";
+          capture_format_.pixel_storage, arbitrary_frame_feedback_id);
+  DLOG_IF(ERROR, !capture_buffer.is_valid())
+      << "Couldn't allocate Capture Buffer";
+  auto buffer_access =
+      capture_buffer.handle_provider()->GetHandleForInProcessAccess();
+  DCHECK(buffer_access->data()) << "Buffer has NO backing memory";
 
   DCHECK_EQ(PIXEL_STORAGE_CPU, capture_format_.pixel_storage);
-  uint8_t* data_ptr = static_cast<uint8_t*>(capture_buffer->data());
-  memset(data_ptr, 0, capture_buffer->mapped_size());
+  uint8_t* data_ptr = buffer_access->data();
+  memset(data_ptr, 0, buffer_access->mapped_size());
   DrawPacman(capture_format_.pixel_format, data_ptr, elapsed_time_,
              fake_capture_rate_, capture_format_.frame_size, current_zoom_);
 
   // Give the captured frame to the client.
   base::TimeTicks now = base::TimeTicks::Now();
   if (first_ref_time_.is_null())
     first_ref_time_ = now;
   client_->OnIncomingCapturedBuffer(std::move(capture_buffer), capture_format_,
                                     now, now - first_ref_time_);
 
@@ skipping 24 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