Make RenderWidgetHostViewAura::CopyFromCompositingSurface readback layer

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 "base/command_line.h"
 #include "base/message_loop/message_loop_proxy.h"
 #include "base/path_service.h"
 #include "base/run_loop.h"
 #include "content/browser/gpu/gpu_data_manager_impl.h"
 #include "content/browser/renderer_host/render_widget_host_impl.h"
 #include "content/port/browser/render_widget_host_view_frame_subscriber.h"
 #include "content/port/browser/render_widget_host_view_port.h"
 #include "content/public/browser/compositor_util.h"
 #include "content/public/browser/render_view_host.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/common/content_paths.h"
 #include "content/public/common/content_switches.h"
+#include "content/public/test/browser_test_utils.h"
 #include "content/shell/shell.h"
 #include "content/test/content_browser_test.h"
 #include "content/test/content_browser_test_utils.h"
 #include "media/base/video_frame.h"
 #include "net/base/net_util.h"
 #include "ui/compositor/compositor_setup.h"
+#include "ui/gl/gl_switches.h"
 
 #if defined(OS_MACOSX)
 #include "ui/gl/io_surface_support_mac.h"
 #endif
 
 namespace content {
 namespace {
 
 // Convenience macro: Short-cicuit a pass for the tests where platform support
 // for forced-compositing mode (or disabled-compositing mode) is lacking.
-#define SET_UP_SURFACE_OR_PASS_TEST()  \
-  if (!SetUpSourceSurface()) {  \
+#define SET_UP_SURFACE_OR_PASS_TEST(wait_message)  \
+  if (!SetUpSourceSurface(wait_message)) {  \
     LOG(WARNING)  \
         << ("Blindly passing this test: This platform does not support "  \
             "forced compositing (or forced-disabled compositing) mode.");  \
     return;  \
   }
 
 // Common base class for browser tests.  This is subclassed twice: Once to test
 // the browser in forced-compositing mode, and once to test with compositing
 // mode disabled.
 class RenderWidgetHostViewBrowserTest : public ContentBrowserTest {
  public:
   RenderWidgetHostViewBrowserTest()
       : frame_size_(400, 300),
         callback_invoke_count_(0),
         frames_captured_(0) {}
 
   virtual void SetUpInProcessBrowserTestFixture() OVERRIDE {
     ASSERT_TRUE(PathService::Get(DIR_TEST_DATA, &test_dir_));
     ContentBrowserTest::SetUpInProcessBrowserTestFixture();
   }
 
   // Attempts to set up the source surface.  Returns false if unsupported on the
   // current platform.
-  virtual bool SetUpSourceSurface() = 0;
+  virtual bool SetUpSourceSurface(const char* wait_message) = 0;
 
   int callback_invoke_count() const {
     return callback_invoke_count_;
   }
 
   int frames_captured() const {
     return frames_captured_;
   }
 
   const gfx::Size& frame_size() const {
@@ skipping 55 matching lines @@
                       bool frame_captured) {
     ++callback_invoke_count_;
     if (frame_captured)
       ++frames_captured_;
     if (!quit_closure.is_null())
       loop->PostTask(FROM_HERE, quit_closure);
   }
 
   // Copy one frame using the CopyFromBackingStore API.
   void RunBasicCopyFromBackingStoreTest() {
-    SET_UP_SURFACE_OR_PASS_TEST();
+    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()->CopyFromBackingStore(
           gfx::Rect(),
@@ skipping 45 matching lines @@
   virtual void SetUpCommandLine(CommandLine* command_line) OVERRIDE {
     // Note: Not appending kForceCompositingMode switch here, since not all bots
     // support compositing.  Some bots will run with compositing on, and others
     // won't.  Therefore, the call to SetUpSourceSurface() later on will detect
     // whether compositing mode is actually on or not.  If not, the tests will
     // pass blindly, logging a warning message, since we cannot test what the
     // platform/implementation does not support.
     RenderWidgetHostViewBrowserTest::SetUpCommandLine(command_line);
   }
 
-  virtual bool SetUpSourceSurface() OVERRIDE {
+  virtual GURL TestUrl() {
+    return net::FilePathToFileURL(
+        test_dir().AppendASCII("rwhv_compositing_animation.html"));
+  }
+
+  virtual bool SetUpSourceSurface(const char* wait_message) OVERRIDE {
     if (!IsForceCompositingModeEnabled())
       return false;  // See comment in SetUpCommandLine().
 #if defined(OS_MACOSX)
     CHECK(IOSurfaceSupport::Initialize());
 #endif
-    NavigateToURL(shell(), net::FilePathToFileURL(
-        test_dir().AppendASCII("rwhv_compositing_animation.html")));
+
+    content::DOMMessageQueue message_queue;
+    NavigateToURL(shell(), TestUrl());
+    if (wait_message != NULL) {
+      std::string result(wait_message);
+      if (!message_queue.WaitForMessage(&result)) {
+        EXPECT_TRUE(false) << "WaitForMessage " << result << " failed.";
+        return false;
+      }
+    }
+
 #if !defined(USE_AURA)
     if (!GetRenderWidgetHost()->is_accelerated_compositing_active())
       return false;  // Renderer did not turn on accelerated compositing.
 #endif
 
     // Using accelerated compositing, but a compositing surface might not be
     // available yet.  So, wait for it.
     WaitForCopySourceReady();
     return true;
   }
 };
 
 class NonCompositingRenderWidgetHostViewBrowserTest
     : public RenderWidgetHostViewBrowserTest {
  public:
   virtual void SetUpCommandLine(CommandLine* command_line) OVERRIDE {
     // Note: Appending the kDisableAcceleratedCompositing switch here, but there
     // are some builds that only use compositing and will ignore this switch.
     // Therefore, the call to SetUpSourceSurface() later on will detect whether
     // compositing mode is actually off.  If it's on, the tests will pass
     // blindly, logging a warning message, since we cannot test what the
     // platform/implementation does not support.
     command_line->AppendSwitch(switches::kDisableAcceleratedCompositing);
     RenderWidgetHostViewBrowserTest::SetUpCommandLine(command_line);
   }
 
-  virtual bool SetUpSourceSurface() OVERRIDE {
+  virtual GURL TestUrl() {
+    return GURL("about:blank");
+  }
+
+  virtual bool SetUpSourceSurface(const char* wait_message) OVERRIDE {
     if (IsForceCompositingModeEnabled())
       return false;  // See comment in SetUpCommandLine().
-    NavigateToURL(shell(), GURL("about:blank"));
+
+    content::DOMMessageQueue message_queue;
+    NavigateToURL(shell(), TestUrl());
+    if (wait_message != NULL) {
+      std::string result(wait_message);
+      if (!message_queue.WaitForMessage(&result)) {
+        EXPECT_TRUE(false) << "WaitForMessage " << result << " failed.";
+        return false;
+      }
+    }
+
     WaitForCopySourceReady();
     // Return whether the renderer left accelerated compositing turned off.
     return !GetRenderWidgetHost()->is_accelerated_compositing_active();
   }
 };
 
 class FakeFrameSubscriber : public RenderWidgetHostViewFrameSubscriber {
  public:
   FakeFrameSubscriber(
     RenderWidgetHostViewFrameSubscriber::DeliverFrameCallback callback)
@@ skipping 36 matching lines @@
 // is disabled.
 IN_PROC_BROWSER_TEST_F(NonCompositingRenderWidgetHostViewBrowserTest,
                        CopyFromBackingStore) {
   RunBasicCopyFromBackingStoreTest();
 }
 
 // Tests that the callback passed to CopyFromBackingStore is always called,
 // even when the RenderWidgetHost is deleting in the middle of an async copy.
 IN_PROC_BROWSER_TEST_F(CompositingRenderWidgetHostViewBrowserTest,
                        CopyFromBackingStore_CallbackDespiteDelete) {
-  SET_UP_SURFACE_OR_PASS_TEST();
+  SET_UP_SURFACE_OR_PASS_TEST(NULL);
 
   base::RunLoop run_loop;
   GetRenderViewHost()->CopyFromBackingStore(
       gfx::Rect(),
       frame_size(),
       base::Bind(&RenderWidgetHostViewBrowserTest::FinishCopyFromBackingStore,
                  base::Unretained(this), run_loop.QuitClosure()));
   // Delete the surface before the callback is run.
   GetRenderWidgetHostViewPort()->AcceleratedSurfaceRelease();
   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.
 IN_PROC_BROWSER_TEST_F(CompositingRenderWidgetHostViewBrowserTest,
                        CopyFromCompositingSurface_CallbackDespiteDelete) {
-  SET_UP_SURFACE_OR_PASS_TEST();
+  SET_UP_SURFACE_OR_PASS_TEST(NULL);
   RenderWidgetHostViewPort* const view = GetRenderWidgetHostViewPort();
   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,
           base::Unretained(this), run_loop.QuitClosure()));
   // Delete the surface before the callback is run.
   view->AcceleratedSurfaceRelease();
   run_loop.Run();
 
   EXPECT_EQ(1, callback_invoke_count());
 }
 
 // With compositing turned off, no platforms should support the
 // CopyFromCompositingSurfaceToVideoFrame() API.
 IN_PROC_BROWSER_TEST_F(NonCompositingRenderWidgetHostViewBrowserTest,
                        CopyFromCompositingSurfaceToVideoFrameCallbackTest) {
-  SET_UP_SURFACE_OR_PASS_TEST();
+  SET_UP_SURFACE_OR_PASS_TEST(NULL);
   EXPECT_FALSE(GetRenderWidgetHostViewPort()->CanCopyToVideoFrame());
 }
 
 // Test basic frame subscription functionality.  We subscribe, and then run
 // until at least one DeliverFrameCallback has been invoked.
 IN_PROC_BROWSER_TEST_F(CompositingRenderWidgetHostViewBrowserTest,
                        FrameSubscriberTest) {
-  SET_UP_SURFACE_OR_PASS_TEST();
+  SET_UP_SURFACE_OR_PASS_TEST(NULL);
   RenderWidgetHostViewPort* const view = GetRenderWidgetHostViewPort();
   if (!view->CanSubscribeFrame()) {
     LOG(WARNING) << ("Blindly passing this test: Frame subscription not "
                      "supported on this platform.");
     return;
   }
 #if defined(USE_AURA)
   if (ui::IsTestCompositorEnabled()) {
     LOG(WARNING) << ("Blindly passing this test: Aura test compositor doesn't "
                      "support frame subscription.");
@@ skipping 13 matching lines @@
   view->BeginFrameSubscription(subscriber.Pass());
   run_loop.Run();
   view->EndFrameSubscription();
 
   EXPECT_LE(1, callback_invoke_count());
   EXPECT_LE(1, frames_captured());
 }
 
 // Test that we can copy twice from an accelerated composited page.
 IN_PROC_BROWSER_TEST_F(CompositingRenderWidgetHostViewBrowserTest, CopyTwice) {
-  SET_UP_SURFACE_OR_PASS_TEST();
+  SET_UP_SURFACE_OR_PASS_TEST(NULL);
   RenderWidgetHostViewPort* const view = GetRenderWidgetHostViewPort();
   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 =
@@ skipping 16 matching lines @@
                  base::Unretained(this),
                  base::MessageLoopProxy::current(),
                  run_loop.QuitClosure(),
                  base::Time::Now()));
   run_loop.Run();
 
   EXPECT_EQ(2, callback_invoke_count());
   EXPECT_EQ(2, frames_captured());
 }
 
+class CompositingRenderWidgetHostViewBrowserTestTabCapture
+    : public CompositingRenderWidgetHostViewBrowserTest {
+ public:
+  CompositingRenderWidgetHostViewBrowserTestTabCapture()
+      : expected_copy_from_compositing_surface_result_(false),
+        allowable_error_(0),
+        test_url_("data:text/html,<!doctype html>") {}
+
+  virtual void SetUp() OVERRIDE {
+    ui::DisableTestCompositor();
+    CompositingRenderWidgetHostViewBrowserTest::SetUp();
+  }
+
+  virtual void SetUpCommandLine(CommandLine* command_line) OVERRIDE {
+    // TODO(Hubbe): This code is very similar to some code in
+    // gpu_feature_browsertest.cc, and should really be shared in a common
+    // location.
+    if (!command_line->HasSwitch(switches::kUseGpuInTests)) {
+      CHECK(!command_line->HasSwitch(switches::kUseGL))
+          << "kUseGL must not be set by test framework code!";
+      command_line->AppendSwitchASCII(switches::kUseGL,
+                                      gfx::kGLImplementationOSMesaName);
+    }
+  }
+
+  void CopyFromCompositingSurfaceCallback(base::Closure quit_callback,
+                                          bool result,
+                                          const SkBitmap& bitmap) {
+    EXPECT_EQ(expected_copy_from_compositing_surface_result_, result);
+
+    const SkBitmap& expected_bitmap =
+        expected_copy_from_compositing_surface_bitmap_;
+    EXPECT_EQ(expected_bitmap.width(), bitmap.width());
+    EXPECT_EQ(expected_bitmap.height(), bitmap.height());
+    EXPECT_EQ(expected_bitmap.config(), bitmap.config());
+    SkAutoLockPixels expected_bitmap_lock(expected_bitmap);
+    SkAutoLockPixels bitmap_lock(bitmap);
+    int fails = 0;
+    for (int i = 0; i < bitmap.width() && fails < 10; ++i) {
+      for (int j = 0; j < bitmap.height() && fails < 10; ++j) {
+        SkColor expected_color = expected_bitmap.getColor(i, j);
+        SkColor color = bitmap.getColor(i, j);
+        EXPECT_NEAR(expected_color, color, allowable_error_)
+            << "expected_color: " << std::hex << expected_color
+            << " color: " <<  color
+            << " Failed at " << std::dec << i << ", " << j
+            << " Failure " << ++fails;
+      }
+    }
+    EXPECT_LT(fails, 10);
+
+    quit_callback.Run();
+ }
+
+  void SetExpectedCopyFromCompositingSurfaceResult(bool result,
+                                                   const SkBitmap& bitmap) {
+    expected_copy_from_compositing_surface_result_ = result;
+    expected_copy_from_compositing_surface_bitmap_ = bitmap;
+  }
+
+  void SetAllowableError(int amount) { allowable_error_ = amount; }
+
+  virtual GURL TestUrl() OVERRIDE {
+    return GURL(test_url_);
+  }
+
+  void SetTestUrl(std::string url) { test_url_ = url; }
+
+ private:
+  bool expected_copy_from_compositing_surface_result_;
+  SkBitmap expected_copy_from_compositing_surface_bitmap_;
+  int allowable_error_;
+  std::string test_url_;
+};
+
+IN_PROC_BROWSER_TEST_F(CompositingRenderWidgetHostViewBrowserTestTabCapture,
+                       CopyFromCompositingSurface_Origin_Unscaled) {
+  SetTestUrl("data:text/html,<!doctype html>"
+             "<div class='left'>"
+             "  <div class='right'></div>"
+             "</div>"
+             "<style>"
+             "body { padding: 0; margin: 0; }"
+             ".left { position: absolute;"
+             "        background: #0ff;"
+             "        width: 200px;"
+             "        height: 300px;"
+             "}"
+             ".right { position: absolute;"
+             "         left: 200px;"
+             "         background: #ff0;"
+             "         width: 200px;"
+             "         height: 300px;"
+             "}"
+             "</style>"
+             "<script>"
+             "  domAutomationController.setAutomationId(0);"
+             "  domAutomationController.send(\"DONE\");"
+             "</script>");
+
+  SET_UP_SURFACE_OR_PASS_TEST("\"DONE\"");
+
+  RenderViewHost* const rwh =
+      shell()->web_contents()->GetRenderViewHost();
+  RenderWidgetHostViewPort* rwhvp =
+      static_cast<RenderWidgetHostViewPort*>(rwh->GetView());
+
+  // The page is loaded in the renderer, wait for a new frame to arrive.
+  uint32 frame = rwhvp->RendererFrameNumber();
+  RenderWidgetHostImpl::From(rwh)->ScheduleComposite();

[piman, 2013/07/02 01:49:09]

So, ScheduleComposite early-outs if we're not in compositing mode (or not
yet?)... Not sure what to do about that...
Our infrastructure is terrible :(

[danakj, 2013/07/03 01:08:45]

I think that's okay. We already waited until we received a frame from the
compositor - ie the ui::layer has a texture set on it.

+  while (rwhvp->RendererFrameNumber() == frame)
+    GiveItSomeTime();
+
+  gfx::Rect bounds = gfx::Rect(400, 300);
+  EXPECT_LE(bounds.width(), rwhvp->GetViewBounds().width());
+  EXPECT_LE(bounds.height(), rwhvp->GetViewBounds().height());
+
+  gfx::Size out_size = bounds.size();
+
+  SkBitmap expected_bitmap;
+  expected_bitmap.setConfig(
+      SkBitmap::kARGB_8888_Config, out_size.width(), out_size.height());
+  expected_bitmap.allocPixels();
+  // Left half is #0ff.
+  expected_bitmap.eraseARGB(255, 0, 255, 255);
+  // Right half is #ff0.
+  {
+    SkAutoLockPixels lock(expected_bitmap);
+    for (int i = 0; i < out_size.width() / 2; ++i) {
+      for (int j = 0; j < out_size.height(); ++j) {
+        *expected_bitmap.getAddr32(out_size.width() / 2 + i, j) =
+            SkColorSetARGB(255, 255, 255, 0);
+      }
+    }
+  }
+  SetExpectedCopyFromCompositingSurfaceResult(true, expected_bitmap);
+
+  base::RunLoop run_loop;
+  base::Callback<void(bool, const SkBitmap&)> callback =
+      base::Bind(&CompositingRenderWidgetHostViewBrowserTestTabCapture::
+                     CopyFromCompositingSurfaceCallback,
+                 base::Unretained(this),
+                 run_loop.QuitClosure());
+  rwhvp->CopyFromCompositingSurface(bounds, out_size, callback);
+  run_loop.Run();
+}
+
+IN_PROC_BROWSER_TEST_F(CompositingRenderWidgetHostViewBrowserTestTabCapture,
+                       CopyFromCompositingSurface_Origin_Scaled) {
+  SetTestUrl("data:text/html,<!doctype html>"
+             "<div class='left'>"
+             "  <div class='right'></div>"
+             "</div>"
+             "<style>"
+             "body { padding: 0; margin: 0; }"
+             ".left { position: absolute;"
+             "        background: #0ff;"
+             "        width: 200px;"
+             "        height: 300px;"
+             "}"
+             ".right { position: absolute;"
+             "         left: 200px;"
+             "         background: #ff0;"
+             "         width: 200px;"
+             "         height: 300px;"
+             "}"
+             "</style>"
+             "<script>"
+             "  domAutomationController.setAutomationId(0);"
+             "  domAutomationController.send(\"DONE\");"
+             "</script>");
+
+  SET_UP_SURFACE_OR_PASS_TEST("\"DONE\"");
+
+  RenderViewHost* const rwh =
+      shell()->web_contents()->GetRenderViewHost();
+  RenderWidgetHostViewPort* rwhvp =
+      static_cast<RenderWidgetHostViewPort*>(rwh->GetView());
+
+  // The page is loaded in the renderer, wait for a new frame to arrive.
+  uint32 frame = rwhvp->RendererFrameNumber();
+  RenderWidgetHostImpl::From(rwh)->ScheduleComposite();
+  while (rwhvp->RendererFrameNumber() == frame)
+    GiveItSomeTime();
+
+  gfx::Rect bounds = gfx::Rect(400, 300);
+  EXPECT_LE(bounds.width(), rwhvp->GetViewBounds().width());
+  EXPECT_LE(bounds.height(), rwhvp->GetViewBounds().height());
+
+  // Scale the output to 200x100.
+  gfx::Size out_size(200, 100);
+
+  SkBitmap expected_bitmap;
+  expected_bitmap.setConfig(
+      SkBitmap::kARGB_8888_Config, out_size.width(), out_size.height());
+  expected_bitmap.allocPixels();
+  // Left half is #0ff.
+  expected_bitmap.eraseARGB(255, 0, 255, 255);
+  // Right half is #ff0.
+  {
+    SkAutoLockPixels lock(expected_bitmap);
+    for (int i = 0; i < out_size.width() / 2; ++i) {
+      for (int j = 0; j < out_size.height(); ++j) {
+        *expected_bitmap.getAddr32(out_size.width() / 2 + i, j) =
+            SkColorSetARGB(255, 255, 255, 0);
+      }
+    }
+  }
+  SetExpectedCopyFromCompositingSurfaceResult(true, expected_bitmap);
+
+  base::RunLoop run_loop;
+  base::Callback<void(bool, const SkBitmap&)> callback =
+      base::Bind(&CompositingRenderWidgetHostViewBrowserTestTabCapture::
+                     CopyFromCompositingSurfaceCallback,
+                 base::Unretained(this),
+                 run_loop.QuitClosure());
+  rwhvp->CopyFromCompositingSurface(bounds, out_size, callback);
+  run_loop.Run();
+}
+
+IN_PROC_BROWSER_TEST_F(CompositingRenderWidgetHostViewBrowserTestTabCapture,
+                       CopyFromCompositingSurface_Cropped_Unscaled) {
+  SetTestUrl("data:text/html,<!doctype html>"
+             "<div class='left'>"
+             "  <div class='right'></div>"
+             "</div>"
+             "<style>"
+             "body { padding: 0; margin: 0; }"
+             ".left { position: absolute;"
+             "        background: #0ff;"
+             "        width: 200px;"
+             "        height: 300px;"
+             "}"
+             ".right { position: absolute;"
+             "         left: 200px;"
+             "         background: #ff0;"
+             "         width: 200px;"
+             "         height: 300px;"
+             "}"
+             "</style>"
+             "<script>"
+             "  domAutomationController.setAutomationId(0);"
+             "  domAutomationController.send(\"DONE\");"
+             "</script>");
+
+  SET_UP_SURFACE_OR_PASS_TEST("\"DONE\"");
+
+  RenderViewHost* const rwh =
+      shell()->web_contents()->GetRenderViewHost();
+  RenderWidgetHostViewPort* rwhvp =
+      static_cast<RenderWidgetHostViewPort*>(rwh->GetView());
+
+  // The page is loaded in the renderer, wait for a new frame to arrive.
+  uint32 frame = rwhvp->RendererFrameNumber();
+  RenderWidgetHostImpl::From(rwh)->ScheduleComposite();
+  while (rwhvp->RendererFrameNumber() == frame)
+    GiveItSomeTime();
+
+  gfx::Rect bounds = gfx::Rect(400, 300);
+  EXPECT_LE(bounds.width(), rwhvp->GetViewBounds().width());
+  EXPECT_LE(bounds.height(), rwhvp->GetViewBounds().height());
+
+  // Grab 60x60 pixels from the center of the tab contents.
+  bounds = gfx::Rect(bounds.CenterPoint() - gfx::Vector2d(30, 30),
+                     gfx::Size(60, 60));
+  gfx::Size out_size = bounds.size();
+
+  SkBitmap expected_bitmap;
+  expected_bitmap.setConfig(
+      SkBitmap::kARGB_8888_Config, out_size.width(), out_size.height());
+  expected_bitmap.allocPixels();
+  // Left half is #0ff.
+  expected_bitmap.eraseARGB(255, 0, 255, 255);
+  // Right half is #ff0.
+  {
+    SkAutoLockPixels lock(expected_bitmap);
+    for (int i = 0; i < out_size.width() / 2; ++i) {
+      for (int j = 0; j < out_size.height(); ++j) {
+        *expected_bitmap.getAddr32(out_size.width() / 2 + i, j) =
+            SkColorSetARGB(255, 255, 255, 0);
+      }
+    }
+  }
+  SetExpectedCopyFromCompositingSurfaceResult(true, expected_bitmap);
+
+  base::RunLoop run_loop;
+  base::Callback<void(bool, const SkBitmap&)> callback =
+      base::Bind(&CompositingRenderWidgetHostViewBrowserTestTabCapture::
+                     CopyFromCompositingSurfaceCallback,
+                 base::Unretained(this),
+                 run_loop.QuitClosure());
+  rwhvp->CopyFromCompositingSurface(bounds, out_size, callback);
+  run_loop.Run();
+}
+
+IN_PROC_BROWSER_TEST_F(CompositingRenderWidgetHostViewBrowserTestTabCapture,
+                       CopyFromCompositingSurface_Cropped_Scaled) {
+  SetTestUrl("data:text/html,<!doctype html>"
+             "<div class='left'>"
+             "  <div class='right'></div>"
+             "</div>"
+             "<style>"
+             "body { padding: 0; margin: 0; }"
+             ".left { position: absolute;"
+             "        background: #0ff;"
+             "        width: 200px;"
+             "        height: 300px;"
+             "}"
+             ".right { position: absolute;"
+             "         left: 200px;"
+             "         background: #ff0;"
+             "         width: 200px;"
+             "         height: 300px;"
+             "}"
+             "</style>"
+             "<script>"
+             "  domAutomationController.setAutomationId(0);"
+             "  domAutomationController.send(\"DONE\");"
+             "</script>");
+
+  SET_UP_SURFACE_OR_PASS_TEST("\"DONE\"");
+
+  RenderViewHost* const rwh =
+      shell()->web_contents()->GetRenderViewHost();
+  RenderWidgetHostViewPort* rwhvp =
+      static_cast<RenderWidgetHostViewPort*>(rwh->GetView());
+
+  // The page is loaded in the renderer, wait for a new frame to arrive.
+  uint32 frame = rwhvp->RendererFrameNumber();
+  RenderWidgetHostImpl::From(rwh)->ScheduleComposite();
+  while (rwhvp->RendererFrameNumber() == frame)
+    GiveItSomeTime();
+
+  gfx::Rect bounds = gfx::Rect(400, 300);
+  EXPECT_LE(bounds.width(), rwhvp->GetViewBounds().width());
+  EXPECT_LE(bounds.height(), rwhvp->GetViewBounds().height());
+
+  // Grab 60x60 pixels from the center of the tab contents.
+  bounds = gfx::Rect(bounds.CenterPoint() - gfx::Vector2d(30, 30),
+                     gfx::Size(60, 60));
+
+  // Scale to 20 x 10.
+  gfx::Size out_size(20, 10);
+
+  SkBitmap expected_bitmap;
+  expected_bitmap.setConfig(
+      SkBitmap::kARGB_8888_Config, out_size.width(), out_size.height());
+  expected_bitmap.allocPixels();
+  // Left half is #0ff.
+  expected_bitmap.eraseARGB(255, 0, 255, 255);
+  // Right half is #ff0.
+  {
+    SkAutoLockPixels lock(expected_bitmap);
+    for (int i = 0; i < out_size.width() / 2; ++i) {
+      for (int j = 0; j < out_size.height(); ++j) {
+        *expected_bitmap.getAddr32(out_size.width() / 2 + i, j) =
+            SkColorSetARGB(255, 255, 255, 0);
+      }
+    }
+  }
+  SetExpectedCopyFromCompositingSurfaceResult(true, expected_bitmap);
+
+  base::RunLoop run_loop;
+  base::Callback<void(bool, const SkBitmap&)> callback =
+     base::Bind(&CompositingRenderWidgetHostViewBrowserTestTabCapture::
+                     CopyFromCompositingSurfaceCallback,
+                 base::Unretained(this),
+                 run_loop.QuitClosure());
+  rwhvp->CopyFromCompositingSurface(bounds, out_size, callback);
+  run_loop.Run();
+}
+
 #endif  // !defined(OS_ANDROID) && !defined(OS_IOS)
 
 }  // namespace
 }  // namespace content