Consistent CopyFromSurface() API, consolidated to RWHV

content/browser/renderer_host/render_widget_host_view_browsertest.cc

 // Copyright (c) 2013 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 <stdint.h>
 #include <utility>
 
 #include "base/barrier_closure.h"
 #include "base/command_line.h"
 #include "base/location.h"
@@ skipping 93 matching lines @@
             GetRenderWidgetHost());
     CHECK(rwh);
     return rwh;
   }
 
   RenderWidgetHostViewBase* GetRenderWidgetHostView() const {
     return static_cast<RenderWidgetHostViewBase*>(
         GetRenderViewHost()->GetWidget()->GetView());
   }
 
-  // Callback when using CopyFromBackingStore() API.
-  void FinishCopyFromBackingStore(const base::Closure& quit_closure,
-                                  const SkBitmap& bitmap,
-                                  ReadbackResponse response) {
+  // Callback when using CopyFromSurface() API.
+  void FinishCopyFromSurface(const base::Closure& quit_closure,
+                             const SkBitmap& bitmap,
+                             ReadbackResponse response) {
     ++callback_invoke_count_;
     if (response == READBACK_SUCCESS) {
       ++frames_captured_;
       EXPECT_FALSE(bitmap.empty());
     }
     if (!quit_closure.is_null())
       quit_closure.Run();
   }
 
-  // Callback when using CopyFromCompositingSurfaceToVideoFrame() API.
-  void FinishCopyFromCompositingSurface(const base::Closure& quit_closure,
-                                        const gfx::Rect& region_in_frame,
-                                        bool frame_captured) {
+  // Callback when using CopyFromSurfaceToVideoFrame() API.
+  void FinishCopyFromSurfaceToVideoFrame(const base::Closure& quit_closure,
+                                         const gfx::Rect& region_in_frame,
+                                         bool frame_captured) {
     ++callback_invoke_count_;
     if (frame_captured)
       ++frames_captured_;
     if (!quit_closure.is_null())
       quit_closure.Run();
   }
 
   // Callback when using frame subscriber API.
   void FrameDelivered(
       const scoped_refptr<base::SingleThreadTaskRunner>& task_runner,
       base::Closure quit_closure,
       base::TimeTicks timestamp,
       const gfx::Rect& region_in_frame,
       bool frame_captured) {
     ++callback_invoke_count_;
     if (frame_captured)
       ++frames_captured_;
     if (!quit_closure.is_null())
       task_runner->PostTask(FROM_HERE, quit_closure);
   }
 
-  // Copy one frame using the CopyFromBackingStore API.
-  void RunBasicCopyFromBackingStoreTest() {
+  // Copy one frame using the CopyFromSurface API.
+  void RunBasicCopyFromSurfaceTest() {
     SET_UP_SURFACE_OR_PASS_TEST(NULL);
 
     // Repeatedly call CopyFromBackingStore() since, on some platforms (e.g.,
     // Windows), the operation will fail until the first "present" has been
     // made.
     int count_attempts = 0;
     while (true) {
       ++count_attempts;
       base::RunLoop run_loop;
-      GetRenderViewHost()->GetWidget()->CopyFromBackingStore(
+      GetRenderWidgetHostView()->CopyFromSurface(
           gfx::Rect(), frame_size(),
-          base::Bind(
-              &RenderWidgetHostViewBrowserTest::FinishCopyFromBackingStore,
-              base::Unretained(this), run_loop.QuitClosure()),
+          base::Bind(&RenderWidgetHostViewBrowserTest::FinishCopyFromSurface,
+                     base::Unretained(this), run_loop.QuitClosure()),
           kN32_SkColorType);
       run_loop.Run();
 
       if (frames_captured())
         break;
       else
         GiveItSomeTime();
     }
 
     EXPECT_EQ(count_attempts, callback_invoke_count());
@@ skipping 98 matching lines @@
   }
 
  private:
   DeliverFrameCallback callback_;
   base::UnguessableToken source_id_for_copy_request_;
 };
 
 // Disable tests for Android as it has an incomplete implementation.
 #if !defined(OS_ANDROID)
 
-// The CopyFromBackingStore() API should work on all platforms when compositing
-// is enabled.
+// The CopyFromSurface() API should work on all platforms when compositing is
+// enabled.
 IN_PROC_BROWSER_TEST_P(CompositingRenderWidgetHostViewBrowserTest,
-                       CopyFromBackingStore) {
-  RunBasicCopyFromBackingStoreTest();
+                       CopyFromSurface) {
+  RunBasicCopyFromSurfaceTest();
 }
 
-// Tests that the callback passed to CopyFromBackingStore is always called,
-// even when the RenderWidgetHost is deleting in the middle of an async copy.
+// Tests that the callback passed to CopyFromSurface is always called, even
+// when the RenderWidgetHostView is deleting in the middle of an async copy.
 IN_PROC_BROWSER_TEST_P(CompositingRenderWidgetHostViewBrowserTest,
-                       CopyFromBackingStore_CallbackDespiteDelete) {
+                       CopyFromSurface_CallbackDespiteDelete) {
   SET_UP_SURFACE_OR_PASS_TEST(NULL);
 
   base::RunLoop run_loop;
-  GetRenderViewHost()->GetWidget()->CopyFromBackingStore(
+  GetRenderWidgetHostView()->CopyFromSurface(
       gfx::Rect(), frame_size(),
-      base::Bind(&RenderWidgetHostViewBrowserTest::FinishCopyFromBackingStore,
+      base::Bind(&RenderWidgetHostViewBrowserTest::FinishCopyFromSurface,
                  base::Unretained(this), run_loop.QuitClosure()),
       kN32_SkColorType);
   run_loop.Run();
 
   EXPECT_EQ(1, callback_invoke_count());
 }
 
-// Tests that the callback passed to CopyFromCompositingSurfaceToVideoFrame is
-// always called, even when the RenderWidgetHost is deleting in the middle of
-// an async copy.
+// Tests that the callback passed to CopyFromSurfaceToVideoFrame is always
+// called, even when the RenderWidgetHostView is deleting in the middle of an
+// async copy.
 IN_PROC_BROWSER_TEST_P(CompositingRenderWidgetHostViewBrowserTest,
-                       CopyFromCompositingSurface_CallbackDespiteDelete) {
+                       CopyFromSurfaceToVideoFrame_CallbackDespiteDelete) {
   SET_UP_SURFACE_OR_PASS_TEST(NULL);
-  RenderWidgetHostViewBase* const view = GetRenderWidgetHostView();
-  if (!view->CanCopyToVideoFrame()) {
-    LOG(WARNING) <<
-        ("Blindly passing this test: CopyFromCompositingSurfaceToVideoFrame() "
-         "not supported on this platform.");
-    return;
-  }
 
   base::RunLoop run_loop;
   scoped_refptr<media::VideoFrame> dest =
       media::VideoFrame::CreateBlackFrame(frame_size());
-  view->CopyFromCompositingSurfaceToVideoFrame(
-      gfx::Rect(view->GetViewBounds().size()), dest, base::Bind(
-          &RenderWidgetHostViewBrowserTest::FinishCopyFromCompositingSurface,
+  GetRenderWidgetHostView()->CopyFromSurfaceToVideoFrame(
+      gfx::Rect(), dest,
+      base::Bind(
+          &RenderWidgetHostViewBrowserTest::FinishCopyFromSurfaceToVideoFrame,
           base::Unretained(this), run_loop.QuitClosure()));
   run_loop.Run();
 
   EXPECT_EQ(1, callback_invoke_count());
 }
 
 // Test basic frame subscription functionality.  We subscribe, and then run
 // until at least one DeliverFrameCallback has been invoked.
 IN_PROC_BROWSER_TEST_P(CompositingRenderWidgetHostViewBrowserTest,
                        FrameSubscriberTest) {
@@ skipping 10 matching lines @@
   run_loop.Run();
   view->EndFrameSubscription();
 
   EXPECT_LE(1, callback_invoke_count());
   EXPECT_LE(1, frames_captured());
 }
 
 IN_PROC_BROWSER_TEST_P(CompositingRenderWidgetHostViewBrowserTest, CopyTwice) {
   SET_UP_SURFACE_OR_PASS_TEST(NULL);
   RenderWidgetHostViewBase* const view = GetRenderWidgetHostView();
-  if (!view->CanCopyToVideoFrame()) {
-    LOG(WARNING) << ("Blindly passing this test: "
-                     "CopyFromCompositingSurfaceToVideoFrame() not supported "
-                     "on this platform.");
-    return;
-  }
 
   base::RunLoop run_loop;
   scoped_refptr<media::VideoFrame> first_output =
       media::VideoFrame::CreateBlackFrame(frame_size());
   ASSERT_TRUE(first_output.get());
   scoped_refptr<media::VideoFrame> second_output =
       media::VideoFrame::CreateBlackFrame(frame_size());
   ASSERT_TRUE(second_output.get());
   base::Closure closure = base::BarrierClosure(2, run_loop.QuitClosure());
-  view->CopyFromCompositingSurfaceToVideoFrame(
-      gfx::Rect(view->GetViewBounds().size()), first_output,
+  view->CopyFromSurfaceToVideoFrame(
+      gfx::Rect(), first_output,
       base::Bind(&RenderWidgetHostViewBrowserTest::FrameDelivered,
                  base::Unretained(this), base::ThreadTaskRunnerHandle::Get(),
                  closure, base::TimeTicks::Now()));
-  view->CopyFromCompositingSurfaceToVideoFrame(
-      gfx::Rect(view->GetViewBounds().size()), second_output,
+  view->CopyFromSurfaceToVideoFrame(
+      gfx::Rect(), second_output,
       base::Bind(&RenderWidgetHostViewBrowserTest::FrameDelivered,
                  base::Unretained(this), base::ThreadTaskRunnerHandle::Get(),
                  closure, base::TimeTicks::Now()));
   run_loop.Run();
 
   EXPECT_EQ(2, callback_invoke_count());
   EXPECT_EQ(2, frames_captured());
 }
 
 class CompositingRenderWidgetHostViewBrowserTestTabCapture
@@ skipping 171 matching lines @@
         box_size.height(),
         box_size.width(),
         box_size.width(),
         box_size.height()));
 
     SET_UP_SURFACE_OR_PASS_TEST("\"DONE\"");
     if (!ShouldContinueAfterTestURLLoad())
       return;
 
     RenderWidgetHostViewBase* rwhv = GetRenderWidgetHostView();
-    ASSERT_TRUE(!video_frame || rwhv->CanCopyToVideoFrame());
 
     SetupLeftRightBitmap(output_size,
                          &expected_copy_from_compositing_surface_bitmap_);
 
     // The page is loaded in the renderer.  Request frames from the renderer
     // until readback succeeds.  When readback succeeds, the resulting
     // SkBitmap/VideoFrame is examined to ensure it matches the expected result.
     // This loop is needed because:
     //   1. Painting/Compositing is not synchronous with the Javascript engine,
     //      and so the "DONE" signal above could be received before the renderer
@@ skipping 26 matching lines @@
         scoped_refptr<media::VideoFrame> video_frame =
             media::VideoFrame::CreateFrame(media::PIXEL_FORMAT_YV12,
                                            output_size, gfx::Rect(output_size),
                                            output_size, base::TimeDelta());
 
         base::Callback<void(const gfx::Rect& rect, bool success)> callback =
             base::Bind(&CompositingRenderWidgetHostViewBrowserTestTabCapture::
                            ReadbackRequestCallbackForVideo,
                        base::Unretained(this), video_frame,
                        run_loop.QuitClosure());
-        rwhv->CopyFromCompositingSurfaceToVideoFrame(
-            copy_rect, video_frame, callback);
+        rwhv->CopyFromSurfaceToVideoFrame(copy_rect, video_frame, callback);
       } else {
         if (!content::GpuDataManager::GetInstance()
                  ->CanUseGpuBrowserCompositor()) {
           // Skia rendering can cause color differences, particularly in the
           // middle two columns.
           SetAllowableError(2);
           SetExcludeRect(gfx::Rect(output_size.width() / 2 - 1, 0, 2,
                                    output_size.height()));
         }
 
         const ReadbackRequestCallback callback =
             base::Bind(&CompositingRenderWidgetHostViewBrowserTestTabCapture::
                            ReadbackRequestCallbackTest,
                        base::Unretained(this),
                        run_loop.QuitClosure());
-        rwhv->CopyFromCompositingSurface(
-            copy_rect, output_size, callback, kN32_SkColorType);
+        rwhv->CopyFromSurface(copy_rect, output_size, callback,
+                              kN32_SkColorType);
       }
       run_loop.Run();
 
       // If the readback operation did not provide a frame, log the reason
       // to aid in future debugging.  This information will also help determine
       // whether the implementation is broken, or a test bot is in a bad state.
       #define CASE_LOG_READBACK_WARNING(enum_value) \
         case enum_value: \
           LOG(WARNING) << "Readback attempt failed (render frame #" \
                        << last_frame_number << ").  Reason: " #enum_value; \
@@ skipping 49 matching lines @@
   // |readback_response_| is always a content::ReadbackResponse or
   // ExtraReadbackResponsesForTest enum value.
   int readback_response_;
   SkBitmap expected_copy_from_compositing_surface_bitmap_;
   int allowable_error_;
   gfx::Rect exclude_rect_;
   std::string test_url_;
 };
 
 IN_PROC_BROWSER_TEST_P(CompositingRenderWidgetHostViewBrowserTestTabCapture,
-                       CopyFromCompositingSurface_Origin_Unscaled) {
+                       CopyFromSurface_Origin_Unscaled) {
   gfx::Rect copy_rect(400, 300);
   gfx::Size output_size = copy_rect.size();
   gfx::Size html_rect_size(400, 300);
   bool video_frame = false;
   PerformTestWithLeftRightRects(html_rect_size,
                                 copy_rect,
                                 output_size,
                                 video_frame);
 }
 
 IN_PROC_BROWSER_TEST_P(CompositingRenderWidgetHostViewBrowserTestTabCapture,
-                       CopyFromCompositingSurface_Origin_Scaled) {
+                       CopyFromSurface_Origin_Scaled) {
   gfx::Rect copy_rect(400, 300);
   gfx::Size output_size(200, 100);
   gfx::Size html_rect_size(400, 300);
   bool video_frame = false;
   PerformTestWithLeftRightRects(html_rect_size,
                                 copy_rect,
                                 output_size,
                                 video_frame);
 }
 
 IN_PROC_BROWSER_TEST_P(CompositingRenderWidgetHostViewBrowserTestTabCapture,
-                       CopyFromCompositingSurface_Cropped_Unscaled) {
+                       CopyFromSurface_Cropped_Unscaled) {
   // Grab 60x60 pixels from the center of the tab contents.
   gfx::Rect copy_rect(400, 300);
   copy_rect = gfx::Rect(copy_rect.CenterPoint() - gfx::Vector2d(30, 30),
                         gfx::Size(60, 60));
   gfx::Size output_size = copy_rect.size();
   gfx::Size html_rect_size(400, 300);
   bool video_frame = false;
   PerformTestWithLeftRightRects(html_rect_size,
                                 copy_rect,
                                 output_size,
                                 video_frame);
 }
 
 IN_PROC_BROWSER_TEST_P(CompositingRenderWidgetHostViewBrowserTestTabCapture,
-                       CopyFromCompositingSurface_Cropped_Scaled) {
+                       CopyFromSurface_Cropped_Scaled) {
   // Grab 60x60 pixels from the center of the tab contents.
   gfx::Rect copy_rect(400, 300);
   copy_rect = gfx::Rect(copy_rect.CenterPoint() - gfx::Vector2d(30, 30),
                         gfx::Size(60, 60));
   gfx::Size output_size(20, 10);
   gfx::Size html_rect_size(400, 300);
   bool video_frame = false;
   PerformTestWithLeftRightRects(html_rect_size,
                                 copy_rect,
                                 output_size,
                                 video_frame);
 }
 
 IN_PROC_BROWSER_TEST_P(CompositingRenderWidgetHostViewBrowserTestTabCapture,
-                       CopyFromCompositingSurface_ForVideoFrame) {
+                       CopyFromSurface_ForVideoFrame) {
   // Grab 90x60 pixels from the center of the tab contents.
   gfx::Rect copy_rect(400, 300);
   copy_rect = gfx::Rect(copy_rect.CenterPoint() - gfx::Vector2d(45, 30),
                         gfx::Size(90, 60));
   gfx::Size output_size = copy_rect.size();
   gfx::Size html_rect_size(400, 300);
   bool video_frame = true;
   PerformTestWithLeftRightRects(html_rect_size,
                                 copy_rect,
                                 output_size,
                                 video_frame);
 }
 
 IN_PROC_BROWSER_TEST_P(CompositingRenderWidgetHostViewBrowserTestTabCapture,
-                       CopyFromCompositingSurface_ForVideoFrame_Scaled) {
+                       CopyFromSurface_ForVideoFrame_Scaled) {
   // Grab 90x60 pixels from the center of the tab contents.
   gfx::Rect copy_rect(400, 300);
   copy_rect = gfx::Rect(copy_rect.CenterPoint() - gfx::Vector2d(45, 30),
                         gfx::Size(90, 60));
   // Scale to 30 x 20 (preserve aspect ratio).
   gfx::Size output_size(30, 20);
   gfx::Size html_rect_size(400, 300);
   bool video_frame = true;
   PerformTestWithLeftRightRects(html_rect_size,
                                 copy_rect,
@@ skipping 162 matching lines @@
                         kTestCompositingModes);
 INSTANTIATE_TEST_CASE_P(
     GLAndSoftwareCompositing,
     CompositingRenderWidgetHostViewBrowserTestTabCaptureHighDPI,
     kTestCompositingModes);
 
 #endif  // !defined(OS_ANDROID)
 
 }  // namespace
 }  // namespace content