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

media/capture/content/thread_safe_capture_oracle.cc

 // Copyright 2014 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/content/thread_safe_capture_oracle.h"
 
 #include <stdint.h>
 
 #include <memory>
 #include <utility>
@@ skipping 43 matching lines @@
     VideoCaptureOracle::Event event,
     const gfx::Rect& damage_rect,
     base::TimeTicks event_time,
     scoped_refptr<VideoFrame>* storage,
     CaptureFrameCallback* callback) {
   // Grab the current time before waiting to acquire the |lock_|.
   const base::TimeTicks capture_begin_time = base::TimeTicks::Now();
 
   gfx::Size visible_size;
   gfx::Size coded_size;
-  std::unique_ptr<media::VideoCaptureDevice::Client::Buffer> output_buffer;
+  media::VideoCaptureDevice::Client::Buffer output_buffer;
   double attenuated_utilization;
   int frame_number;
   base::TimeDelta estimated_frame_duration;
   {
     base::AutoLock guard(lock_);
 
     if (!client_)
       return false;  // Capture is stopped.
 
     if (!oracle_.ObserveEventAndDecideCapture(event, damage_rect, event_time)) {
@@ skipping 11 matching lines @@
     // TODO(miu): Clients should request exact padding, instead of this
     // memory-wasting hack to make frames that are compatible with all HW
     // encoders.  http://crbug.com/555911
     coded_size.SetSize(base::bits::Align(visible_size.width(), 16),
                        base::bits::Align(visible_size.height(), 16));
 
     if (event == VideoCaptureOracle::kPassiveRefreshRequest) {
       output_buffer = client_->ResurrectLastOutputBuffer(
           coded_size, params_.requested_format.pixel_format,
           params_.requested_format.pixel_storage, frame_number);
-      if (!output_buffer) {
+      if (!output_buffer.is_valid()) {
         TRACE_EVENT_INSTANT0("gpu.capture", "ResurrectionFailed",
                              TRACE_EVENT_SCOPE_THREAD);
         return false;
       }
     } else {
       output_buffer = client_->ReserveOutputBuffer(
           coded_size, params_.requested_format.pixel_format,
           params_.requested_format.pixel_storage, frame_number);
     }
 
     // Get the current buffer pool utilization and attenuate it: The utilization
     // reported to the oracle is in terms of a maximum sustainable amount (not
     // the absolute maximum).
     attenuated_utilization = client_->GetBufferPoolUtilization() *
                              (100.0 / kTargetMaxPoolUtilizationPercent);
 
-    if (!output_buffer) {
+    if (!output_buffer.is_valid()) {
       TRACE_EVENT_INSTANT2(
           "gpu.capture", "PipelineLimited", TRACE_EVENT_SCOPE_THREAD, "trigger",
           VideoCaptureOracle::EventAsString(event), "atten_util_percent",
           base::saturated_cast<int>(attenuated_utilization * 100.0 + 0.5));
       oracle_.RecordWillNotCapture(attenuated_utilization);
       return false;
     }
 
     oracle_.RecordCapture(attenuated_utilization);
     estimated_frame_duration = oracle_.estimated_frame_duration();
   }  // End of critical section.
 
   if (attenuated_utilization >= 1.0) {
     TRACE_EVENT_INSTANT2(
         "gpu.capture", "NearlyPipelineLimited", TRACE_EVENT_SCOPE_THREAD,
         "trigger", VideoCaptureOracle::EventAsString(event),
         "atten_util_percent",
         base::saturated_cast<int>(attenuated_utilization * 100.0 + 0.5));
   }
 
-  TRACE_EVENT_ASYNC_BEGIN2("gpu.capture", "Capture", output_buffer.get(),
+  TRACE_EVENT_ASYNC_BEGIN2("gpu.capture", "Capture", output_buffer.id(),
                            "frame_number", frame_number, "trigger",
                            VideoCaptureOracle::EventAsString(event));
 
+  auto output_buffer_access =
+      output_buffer.handle_provider->GetHandleForInProcessAccess();
   DCHECK_EQ(media::PIXEL_STORAGE_CPU, params_.requested_format.pixel_storage);
   *storage = VideoFrame::WrapExternalSharedMemory(
       params_.requested_format.pixel_format, coded_size,
-      gfx::Rect(visible_size), visible_size,
-      static_cast<uint8_t*>(output_buffer->data()),
-      output_buffer->mapped_size(), base::SharedMemory::NULLHandle(), 0u,
+      gfx::Rect(visible_size), visible_size, output_buffer_access->data(),
+      output_buffer_access->mapped_size(), base::SharedMemory::NULLHandle(), 0u,
       base::TimeDelta());
   // If creating the VideoFrame wrapper failed, call DidCaptureFrame() with
   // !success to execute the required post-capture steps (tracing, notification
   // of failure to VideoCaptureOracle, etc.).
   if (!(*storage)) {
     DidCaptureFrame(frame_number, std::move(output_buffer), capture_begin_time,
                     estimated_frame_duration, *storage, event_time, false);
     return false;
   }
 
@@ skipping 38 matching lines @@
 void ThreadSafeCaptureOracle::ReportError(
     const tracked_objects::Location& from_here,
     const std::string& reason) {
   base::AutoLock guard(lock_);
   if (client_)
     client_->OnError(from_here, reason);
 }
 
 void ThreadSafeCaptureOracle::DidCaptureFrame(
     int frame_number,
-    std::unique_ptr<VideoCaptureDevice::Client::Buffer> buffer,
+    VideoCaptureDevice::Client::Buffer buffer,
     base::TimeTicks capture_begin_time,
     base::TimeDelta estimated_frame_duration,
     scoped_refptr<VideoFrame> frame,
     base::TimeTicks reference_time,
     bool success) {
-  TRACE_EVENT_ASYNC_END2("gpu.capture", "Capture", buffer.get(), "success",
+  TRACE_EVENT_ASYNC_END2("gpu.capture", "Capture", buffer.id(), "success",
                          success, "timestamp",
                          reference_time.ToInternalValue());
 
   base::AutoLock guard(lock_);
 
   if (!oracle_.CompleteCapture(frame_number, success, &reference_time))
     return;
 
   TRACE_EVENT_INSTANT0("gpu.capture", "CaptureSucceeded",
                        TRACE_EVENT_SCOPE_THREAD);
@@ skipping 22 matching lines @@
 }
 
 void ThreadSafeCaptureOracle::OnConsumerReportingUtilization(
     int frame_number,
     double utilization) {
   base::AutoLock guard(lock_);
   oracle_.RecordConsumerFeedback(frame_number, utilization);
 }
 
 }  // namespace media