Revert of [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));
 
-  media::VideoCaptureDevice::Client::Buffer ReserveOutputBuffer(
-      const gfx::Size& dimensions,
-      media::VideoPixelFormat format,
-      media::VideoPixelStorage storage,
-      int frame_feedback_id) override {
+  std::unique_ptr<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 media::VideoCaptureDevice::Client::Buffer();
+      return NULL;
 
-    return media::VideoCaptureDeviceClient::MakeBufferStruct(
-        buffer_pool_, buffer_id, frame_feedback_id);
+    return std::unique_ptr<media::VideoCaptureDevice::Client::Buffer>(
+        new AutoReleaseBuffer(buffer_pool_,
+                              buffer_pool_->GetBufferHandle(buffer_id),
+                              buffer_id, frame_feedback_id));
   }
 
   // Trampoline method to workaround GMOCK problems with std::unique_ptr<>.
-  void OnIncomingCapturedBuffer(Buffer buffer,
+  void OnIncomingCapturedBuffer(std::unique_ptr<Buffer> buffer,
                                 const media::VideoCaptureFormat& format,
                                 base::TimeTicks reference_time,
                                 base::TimeDelta timestamp) override {
     DoOnIncomingCapturedBuffer();
   }
 
   void OnIncomingCapturedBufferExt(
-      media::VideoCaptureDevice::Client::Buffer buffer,
+      std::unique_ptr<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, buffer_access->data(), buffer_access->mapped_size(),
-        base::SharedMemory::NULLHandle(), 0u, base::TimeDelta());
+        format.frame_size, static_cast<uint8_t*>(buffer->data()),
+        buffer->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());
   }
 
-  media::VideoCaptureDevice::Client::Buffer ResurrectLastOutputBuffer(
-      const gfx::Size& dimensions,
-      media::VideoPixelFormat format,
-      media::VideoPixelStorage storage,
-      int frame_feedback_id) override {
+  std::unique_ptr<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 media::VideoCaptureDevice::Client::Buffer();
-    return media::VideoCaptureDeviceClient::MakeBufferStruct(
-        buffer_pool_, buffer_id, frame_feedback_id);
+      return nullptr;
+    return std::unique_ptr<media::VideoCaptureDevice::Client::Buffer>(
+        new AutoReleaseBuffer(buffer_pool_,
+                              buffer_pool_->GetBufferHandle(buffer_id),
+                              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