Consistent CopyFromSurface() API, consolidated to RWHV

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 81 matching lines @@
 
 media::VideoCaptureParams DefaultCaptureParams() {
   media::VideoCaptureParams capture_params;
   capture_params.requested_format.frame_size.SetSize(kTestWidth, kTestHeight);
   capture_params.requested_format.frame_rate = kTestFramesPerSecond;
   capture_params.requested_format.pixel_format = media::PIXEL_FORMAT_I420;
   return capture_params;
 }
 
 // A stub implementation which fills solid-colors into VideoFrames in calls to
-// CopyFromCompositingSurfaceToVideoFrame(). The colors are changed by tests
-// in-between draw events to confirm that the right frames have the right
-// content and in the right sequence.
+// CopyFromSurfaceToVideoFrame(). The colors are changed by tests in-between
+// draw events to confirm that the right frames have the right content and in
+// the right sequence.
 class CaptureTestView : public TestRenderWidgetHostView {
  public:
   explicit CaptureTestView(RenderWidgetHostImpl* rwh)
       : TestRenderWidgetHostView(rwh),
         fake_bounds_(100, 100, 100 + kTestWidth, 100 + kTestHeight),
         yuv_color_(kDrawColorNotSet) {}
 
   ~CaptureTestView() override {}
 
   // TestRenderWidgetHostView overrides.
   gfx::Rect GetViewBounds() const override {
     return fake_bounds_;
   }
 
   void SetSize(const gfx::Size& size) override {
     SetBounds(gfx::Rect(fake_bounds_.origin(), size));
   }
 
   void SetBounds(const gfx::Rect& rect) override {
     fake_bounds_ = rect;
   }
 
-  bool CanCopyToVideoFrame() const override { return true; }
+  bool IsSurfaceAvailableForCopy() const override { return true; }
 
-  void CopyFromCompositingSurfaceToVideoFrame(
+  void CopyFromSurface(const gfx::Rect& src_rect,
+                       const gfx::Size& output_size,
+                       const ReadbackRequestCallback& callback,
+                       const SkColorType color_type) override {
+    // WebContentsVideoCaptureDevice implementation does not use this.
+    NOTREACHED();
+  }
+
+  void CopyFromSurfaceToVideoFrame(
       const gfx::Rect& src_subrect,
-      const scoped_refptr<media::VideoFrame>& target,
+      scoped_refptr<media::VideoFrame> target,
       const base::Callback<void(const gfx::Rect&, bool)>& callback) override {
+    ASSERT_TRUE(src_subrect.IsEmpty());
     media::FillYUV(target.get(), SkColorGetR(yuv_color_),
                    SkColorGetG(yuv_color_), SkColorGetB(yuv_color_));
     BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
                             base::Bind(callback, gfx::Rect(), true));
   }
 
   void BeginFrameSubscription(
       std::unique_ptr<RenderWidgetHostViewFrameSubscriber> subscriber)
       override {
     subscriber_ = std::move(subscriber);
   }
 
   void EndFrameSubscription() override { subscriber_.reset(); }
 
   void SetSolidColor(SkColor rgb_color) {
     yuv_color_ = ConvertRgbToYuv(rgb_color);
   }
 
   // Simulate a compositor paint event for our subscriber.
   void SimulateUpdate() {
     const base::TimeTicks present_time = base::TimeTicks::Now();
     RenderWidgetHostViewFrameSubscriber::DeliverFrameCallback callback;
     scoped_refptr<media::VideoFrame> target;
     if (subscriber_ && subscriber_->ShouldCaptureFrame(
             gfx::Rect(), present_time, &target, &callback)) {
-      CopyFromCompositingSurfaceToVideoFrame(
-          gfx::Rect(), target, base::Bind(callback, present_time));
+      CopyFromSurfaceToVideoFrame(gfx::Rect(), target,
+                                  base::Bind(callback, present_time));
     }
   }
 
  private:
   std::unique_ptr<RenderWidgetHostViewFrameSubscriber> subscriber_;
   gfx::Rect fake_bounds_;
   SkColor yuv_color_;
 
   DISALLOW_IMPLICIT_CONSTRUCTORS(CaptureTestView);
 };
@@ skipping 274 matching lines @@
     display.set_device_scale_factor(kTestDeviceScaleFactor);
     test_screen_.display_list().RemoveDisplay(test_display.id());
     test_screen_.display_list().AddDisplay(display,
                                            display::DisplayList::Type::PRIMARY);
     display::Screen::SetScreenInstance(&test_screen_);
     ASSERT_EQ(&test_screen_, display::Screen::GetScreen());
 
     // TODO(nick): Sadness and woe! Much "mock-the-world" boilerplate could be
     // eliminated here, if only we could use RenderViewHostTestHarness. The
     // catch is that we need to inject our CaptureTestView::
-    // CopyFromCompositingSurfaceToVideoFrame() mock. To accomplish that,
-    // either RenderViewHostTestHarness would have to support installing a
-    // custom RenderViewHostFactory, or else we implant some kind of delegated
-    // CopyFromCompositingSurfaceToVideoFrame functionality into
-    // TestRenderViewHostView itself.
+    // CopyFromSurfaceToVideoFrame() mock. To accomplish that, either
+    // RenderViewHostTestHarness would have to support installing a custom
+    // RenderViewHostFactory, or else we implant some kind of delegated
+    // CopyFromSurfaceToVideoFrame functionality into TestRenderWidgetHostView
+    // itself.
 
     render_process_host_factory_.reset(new MockRenderProcessHostFactory());
     // Create our (self-registering) RVH factory, so that when we create a
     // WebContents, it in turn creates CaptureTestRenderViewHosts.
     render_view_host_factory_.reset(new CaptureTestRenderViewHostFactory());
     render_frame_host_factory_.reset(new TestRenderFrameHostFactory());
 
     browser_context_.reset(new TestBrowserContext());
 
     scoped_refptr<SiteInstance> site_instance =
@@ skipping 552 matching lines @@
   for (int i = 0; i < 3; ++i) {
     SimulateRefreshFrameRequest();
     ASSERT_NO_FATAL_FAILURE(client_observer()->WaitForNextColor(SK_ColorGREEN));
   }
 
   device()->StopAndDeAllocate();
 }
 
 }  // namespace
 }  // namespace content