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

content/browser/media/capture/web_contents_video_capture_device_unittest.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 "content/browser/media/capture/web_contents_video_capture_device.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <utility>
@@ skipping 19 matching lines @@
 #include "content/public/test/test_browser_thread_bundle.h"
 #include "content/public/test/test_utils.h"
 #include "content/test/test_render_frame_host_factory.h"
 #include "content/test/test_render_view_host.h"
 #include "content/test/test_web_contents.h"
 #include "media/base/video_frame.h"
 #include "media/base/video_util.h"
 #include "media/base/yuv_convert.h"
 #include "media/capture/video/video_capture_buffer_pool_impl.h"
 #include "media/capture/video/video_capture_buffer_tracker_factory_impl.h"
+#include "media/capture/video/video_capture_device_client.h"
 #include "media/capture/video_capture_types.h"
 #include "skia/ext/platform_canvas.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/skia/include/core/SkColor.h"
 #include "ui/base/layout.h"
 #include "ui/display/display.h"
 #include "ui/display/screen.h"
 #include "ui/display/test/test_screen.h"
 #include "ui/gfx/geometry/dip_util.h"
@@ skipping 292 matching lines @@
                void(const uint8_t* data,
                     int length,
                     const media::VideoCaptureFormat& frame_format,
                     int rotation,
                     base::TimeTicks reference_time,
                     base::TimeDelta timestamp,
                     int frame_feedback_id));
 
   MOCK_METHOD0(DoOnIncomingCapturedBuffer, void(void));
 
-  std::unique_ptr<media::VideoCaptureDevice::Client::Buffer>
-  ReserveOutputBuffer(const gfx::Size& dimensions,
-                      media::VideoPixelFormat format,
-                      media::VideoPixelStorage storage,
-                      int frame_feedback_id) override {
+  media::VideoCaptureDevice::Client::Buffer ReserveOutputBuffer(
+      const gfx::Size& dimensions,
+      media::VideoPixelFormat format,
+      media::VideoPixelStorage storage,
+      int frame_feedback_id) override {
     CHECK_EQ(format, media::PIXEL_FORMAT_I420);
     int buffer_id_to_drop =
         media::VideoCaptureBufferPool::kInvalidId;  // Ignored.
     const int buffer_id = buffer_pool_->ReserveForProducer(
         dimensions, format, storage, frame_feedback_id, &buffer_id_to_drop);
     if (buffer_id == media::VideoCaptureBufferPool::kInvalidId)
-      return NULL;
+      return media::VideoCaptureDevice::Client::Buffer();
 
-    return std::unique_ptr<media::VideoCaptureDevice::Client::Buffer>(
-        new AutoReleaseBuffer(buffer_pool_,
-                              buffer_pool_->GetBufferHandle(buffer_id),
-                              buffer_id, frame_feedback_id));
+    return media::VideoCaptureDeviceClient::MakeBufferStruct(
+        buffer_pool_, buffer_id, frame_feedback_id);
   }
 
   // Trampoline method to workaround GMOCK problems with std::unique_ptr<>.
-  void OnIncomingCapturedBuffer(std::unique_ptr<Buffer> buffer,
+  void OnIncomingCapturedBuffer(Buffer buffer,
                                 const media::VideoCaptureFormat& format,
                                 base::TimeTicks reference_time,
                                 base::TimeDelta timestamp) override {
     DoOnIncomingCapturedBuffer();
   }
 
   void OnIncomingCapturedBufferExt(
-      std::unique_ptr<media::VideoCaptureDevice::Client::Buffer> buffer,
+      media::VideoCaptureDevice::Client::Buffer buffer,
       const media::VideoCaptureFormat& format,
       base::TimeTicks reference_time,
       base::TimeDelta timestamp,
       gfx::Rect visible_rect,
       const media::VideoFrameMetadata& additional_metadata) override {
     EXPECT_FALSE(visible_rect.IsEmpty());
     EXPECT_EQ(media::PIXEL_FORMAT_I420, format.pixel_format);
     EXPECT_EQ(kTestFramesPerSecond, format.frame_rate);
 
     // TODO(miu): We just look at the center pixel presently, because if the
     // analysis is too slow, the backlog of frames will grow without bound and
     // trouble erupts. http://crbug.com/174519
     using media::VideoFrame;
+    auto buffer_access = buffer.handle_provider->GetHandleForInProcessAccess();
     auto frame = VideoFrame::WrapExternalSharedMemory(
         media::PIXEL_FORMAT_I420, format.frame_size, visible_rect,
-        format.frame_size, static_cast<uint8_t*>(buffer->data()),
-        buffer->mapped_size(), base::SharedMemory::NULLHandle(), 0u,
-        base::TimeDelta());
+        format.frame_size, buffer_access->data(), buffer_access->mapped_size(),
+        base::SharedMemory::NULLHandle(), 0u, base::TimeDelta());
     const gfx::Point center = visible_rect.CenterPoint();
     const int center_offset_y =
         (frame->stride(VideoFrame::kYPlane) * center.y()) + center.x();
     const int center_offset_uv =
         (frame->stride(VideoFrame::kUPlane) * (center.y() / 2)) +
         (center.x() / 2);
     report_callback_.Run(
         SkColorSetRGB(frame->data(VideoFrame::kYPlane)[center_offset_y],
                       frame->data(VideoFrame::kUPlane)[center_offset_uv],
                       frame->data(VideoFrame::kVPlane)[center_offset_uv]),
         frame->visible_rect().size());
   }
 
-  std::unique_ptr<media::VideoCaptureDevice::Client::Buffer>
-  ResurrectLastOutputBuffer(const gfx::Size& dimensions,
-                            media::VideoPixelFormat format,
-                            media::VideoPixelStorage storage,
-                            int frame_feedback_id) override {
+  media::VideoCaptureDevice::Client::Buffer ResurrectLastOutputBuffer(
+      const gfx::Size& dimensions,
+      media::VideoPixelFormat format,
+      media::VideoPixelStorage storage,
+      int frame_feedback_id) override {
     CHECK_EQ(format, media::PIXEL_FORMAT_I420);
     const int buffer_id =
         buffer_pool_->ResurrectLastForProducer(dimensions, format, storage);
     if (buffer_id == media::VideoCaptureBufferPool::kInvalidId)
-      return nullptr;
-    return std::unique_ptr<media::VideoCaptureDevice::Client::Buffer>(
-        new AutoReleaseBuffer(buffer_pool_,
-                              buffer_pool_->GetBufferHandle(buffer_id),
-                              buffer_id, frame_feedback_id));
+      return media::VideoCaptureDevice::Client::Buffer();
+    return media::VideoCaptureDeviceClient::MakeBufferStruct(
+        buffer_pool_, buffer_id, frame_feedback_id);
   }
 
   void OnError(const tracked_objects::Location& from_here,
                const std::string& reason) override {
     error_callback_.Run();
   }
 
   double GetBufferPoolUtilization() const override { return 0.0; }
 
  private:
-  class AutoReleaseBuffer : public media::VideoCaptureDevice::Client::Buffer {
-   public:
-    AutoReleaseBuffer(
-        const scoped_refptr<media::VideoCaptureBufferPool>& pool,
-        std::unique_ptr<media::VideoCaptureBufferHandle> buffer_handle,
-        int buffer_id,
-        int frame_feedback_id)
-        : id_(buffer_id),
-          frame_feedback_id_(frame_feedback_id),
-          pool_(pool),
-          buffer_handle_(std::move(buffer_handle)) {
-      DCHECK(pool_);
-    }
-    int id() const override { return id_; }
-    int frame_feedback_id() const override { return frame_feedback_id_; }
-    gfx::Size dimensions() const override {
-      return buffer_handle_->dimensions();
-    }
-    size_t mapped_size() const override {
-      return buffer_handle_->mapped_size();
-    }
-    void* data(int plane) override { return buffer_handle_->data(plane); }
-#if defined(OS_POSIX) && !defined(OS_MACOSX)
-    base::FileDescriptor AsPlatformFile() override {
-      return base::FileDescriptor();
-    }
-#endif
-    bool IsBackedByVideoFrame() const override {
-      return buffer_handle_->IsBackedByVideoFrame();
-    }
-    scoped_refptr<media::VideoFrame> GetVideoFrame() override {
-      return buffer_handle_->GetVideoFrame();
-    }
-
-   private:
-    ~AutoReleaseBuffer() override { pool_->RelinquishProducerReservation(id_); }
-
-    const int id_;
-    const int frame_feedback_id_;
-    const scoped_refptr<media::VideoCaptureBufferPool> pool_;
-    const std::unique_ptr<media::VideoCaptureBufferHandle> buffer_handle_;
-  };
-
   scoped_refptr<media::VideoCaptureBufferPool> buffer_pool_;
   base::Callback<void(SkColor, const gfx::Size&)> report_callback_;
   base::Closure error_callback_;
 
   DISALLOW_COPY_AND_ASSIGN(StubClient);
 };
 
 class StubClientObserver {
  public:
   StubClientObserver()
@@ skipping 788 matching lines @@
   for (int i = 0; i < 3; ++i) {
     SimulateRefreshFrameRequest();
     ASSERT_NO_FATAL_FAILURE(client_observer()->WaitForNextColor(SK_ColorGREEN));
   }
 
   device()->StopAndDeAllocate();
 }
 
 }  // namespace
 }  // namespace content