Tab Capture: Backing store readbacks to YV12 VideoFrames.

content/browser/renderer_host/media/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/renderer_host/media/web_contents_video_capture_device.h"
 
 #include "base/bind_helpers.h"
 #include "base/synchronization/condition_variable.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/time.h"
 #include "content/browser/browser_thread_impl.h"
 #include "content/browser/renderer_host/render_widget_host_delegate.h"
 #include "content/browser/renderer_host/render_widget_host_impl.h"
 #include "content/public/test/mock_render_process_host.h"
 #include "content/public/test/test_browser_context.h"
+#include "media/base/video_util.h"
 #include "media/video/capture/video_capture_types.h"
 #include "skia/ext/platform_canvas.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/skia/include/core/SkColor.h"
 
 namespace content {
 namespace {
 const int kTestWidth = 1280;
 const int kTestHeight = 720;
 const int kBytesPerPixel = 4;
 const int kTestFramesPerSecond = 8;
 const base::TimeDelta kWaitTimeout =
     base::TimeDelta::FromMilliseconds(2000);
 const SkColor kNothingYet = 0xdeadbeef;
 const SkColor kNotInterested = ~kNothingYet;
 }
 
 // A stub implementation which returns solid-color bitmaps in calls to
 // CopyFromBackingStore().  The unit tests can change the color for successive
 // captures.
 class StubRenderWidgetHost : public RenderWidgetHostImpl {
  public:
   StubRenderWidgetHost(RenderProcessHost* process, int routing_id)
       : RenderWidgetHostImpl(&delegate_, process, routing_id),
         color_(kNothingYet),
         copy_result_size_(kTestWidth, kTestHeight),
-        copy_event_(false, false) {}
+        copy_event_(false, false),
+        use_video_frames_(false) {}
 
   void SetSolidColor(SkColor color) {
     base::AutoLock guard(lock_);
     color_ = color;
   }
 
   void SetCopyResultSize(int width, int height) {
     base::AutoLock guard(lock_);
     copy_result_size_ = gfx::Size(width, height);
   }
 
+  void SetUseVideoFrames(bool use_them) {
+    use_video_frames_ = use_them;
+  }
+
   bool WaitForNextBackingStoreCopy() {
     if (!copy_event_.TimedWait(kWaitTimeout)) {
       ADD_FAILURE() << "WaitForNextBackingStoreCopy: wait deadline exceeded";
       return false;
     }
     return true;
   }
 
   // RenderWidgetHostImpl overrides.
   virtual void CopyFromBackingStore(
       const gfx::Rect& src_rect,
       const gfx::Size& accelerated_dst_size,
       const base::Callback<void(bool, const SkBitmap&)>& callback) OVERRIDE {
     // Although it's not necessary, use a PlatformBitmap here (instead of a
     // regular SkBitmap) to exercise possible threading issues.
     scoped_ptr<skia::PlatformBitmap> platform_bitmap(new skia::PlatformBitmap);
     EXPECT_TRUE(platform_bitmap->Allocate(
         copy_result_size_.width(), copy_result_size_.height(), false));
     {
       SkAutoLockPixels locker(platform_bitmap->GetBitmap());
       base::AutoLock guard(lock_);
       platform_bitmap->GetBitmap().eraseColor(color_);
     }
 
     callback.Run(true, platform_bitmap->GetBitmap());
     copy_event_.Signal();
   }
 
+  virtual bool CanCopyToVideoFrame() const OVERRIDE {
+    return use_video_frames_;
+  }
+
+  virtual void CopyFromBackingStoreToVideoFrame(
+      const gfx::Rect& src_rect,
+      const scoped_refptr<media::VideoFrame>& target,
+      const base::Callback<void(bool)>& callback) OVERRIDE {
+    media::FillYUV(target, SkColorGetR(color_), SkColorGetG(color_),
+                   SkColorGetB(color_));
+    callback.Run(true);
+    copy_event_.Signal();
+  }
+
  private:
   class StubRenderWidgetHostDelegate : public RenderWidgetHostDelegate {
    public:
     StubRenderWidgetHostDelegate() {}
     virtual ~StubRenderWidgetHostDelegate() {}
 
    private:
     DISALLOW_COPY_AND_ASSIGN(StubRenderWidgetHostDelegate);
   };
 
   StubRenderWidgetHostDelegate delegate_;
   base::Lock lock_;  // Guards changes to color_.
   SkColor color_;
   gfx::Size copy_result_size_;
   base::WaitableEvent copy_event_;
+  bool use_video_frames_;
 
   DISALLOW_IMPLICIT_CONSTRUCTORS(StubRenderWidgetHost);
 };
 
 // A stub consumer of captured video frames, which checks the output of
 // WebContentsVideoCaptureDevice.
 class StubConsumer : public media::VideoCaptureDevice::EventHandler {
  public:
   StubConsumer() : output_changed_(&lock_),
                    picture_color_(kNothingYet),
@@ skipping 38 matching lines @@
 
     {
       base::AutoLock guard(lock_);
       if (color != picture_color_) {
         picture_color_ = color;
         output_changed_.Signal();
       }
     }
   }
 
+  virtual void OnIncomingCapturedVideoFrame(media::VideoFrame* frame,
+                                            base::Time timestamp) OVERRIDE {
+    EXPECT_EQ(gfx::Size(kTestWidth, kTestHeight), frame->coded_size());
+    EXPECT_EQ(media::VideoFrame::YV12, frame->format());
+    bool all_pixels_are_the_same_color = true;
+    uint8 yuv[3] = {0};
+    for (int plane = 0; plane < 3; ++plane) {
+      yuv[plane] = frame->data(plane)[0];
+      for (int y = 0; y < frame->rows(plane); ++y) {
+        for (int x = 0; x < frame->row_bytes(plane); ++x) {
+          if (yuv[plane] != frame->data(plane)[x + y * frame->stride(plane)]) {
+            all_pixels_are_the_same_color = false;
+            break;
+          }
+        }
+      }
+    }
+    EXPECT_TRUE(all_pixels_are_the_same_color);
+    const SkColor color = SkColorSetRGB(yuv[0], yuv[1], yuv[2]);
+
+    {
+      base::AutoLock guard(lock_);
+      if (color != picture_color_) {
+        picture_color_ = color;
+        output_changed_.Signal();
+      }
+    }
+  }
+
   virtual void OnError() OVERRIDE {
     base::AutoLock guard(lock_);
     error_encountered_ = true;
     output_changed_.Signal();
   }
 
   virtual void OnFrameInfo(const media::VideoCaptureCapability& info) OVERRIDE {
     EXPECT_EQ(kTestWidth, info.width);
     EXPECT_EQ(kTestHeight, info.height);
     EXPECT_EQ(kTestFramesPerSecond, info.frame_rate);
@@ skipping 64 matching lines @@
   scoped_ptr<StubRenderWidgetHost> source_;
   scoped_ptr<base::WaitableEvent> destroyed_;
   scoped_ptr<media::VideoCaptureDevice> device_;
   scoped_ptr<StubConsumer> consumer_;
 
   DISALLOW_COPY_AND_ASSIGN(WebContentsVideoCaptureDeviceTest);
 };
 
 // The "happy case" test.  No scaling is needed, so we should be able to change
 // the picture emitted from the source and expect to see each delivered to the
-// consumer.
+// consumer. The test will alternate between the SkBitmap and the VideoFrame
+// paths, just as RenderWidgetHost might if the content falls in and out of
+// accelerated compositing.
 TEST_F(WebContentsVideoCaptureDeviceTest, GoesThroughAllTheMotions) {
   device()->Allocate(kTestWidth, kTestHeight, kTestFramesPerSecond,
                      consumer());
 
   device()->Start();
-  source()->SetSolidColor(SK_ColorRED);
-  EXPECT_TRUE(consumer()->WaitForNextColorOrError(SK_ColorRED));
-  source()->SetSolidColor(SK_ColorGREEN);
-  EXPECT_TRUE(consumer()->WaitForNextColorOrError(SK_ColorGREEN));
-  source()->SetSolidColor(SK_ColorBLUE);
-  EXPECT_TRUE(consumer()->WaitForNextColorOrError(SK_ColorBLUE));
-  source()->SetSolidColor(SK_ColorBLACK);
-  EXPECT_TRUE(consumer()->WaitForNextColorOrError(SK_ColorBLACK));
+
+  bool use_video_frames = false;
+  for (int i = 0; i < 4; i++, use_video_frames = !use_video_frames) {
+    SCOPED_TRACE(
+        testing::Message() << "Using "

[scherkus (not reviewing), 2013/02/07 18:25:03]

nit: you can also use base::StringPrintf() if you like printfs() over
operator<<()

+                           << (use_video_frames ? "VideoFrame" : "SkBitmap")
+                           << " path, iteration #" << i);
+    source()->SetUseVideoFrames(use_video_frames);
+    source()->SetSolidColor(SK_ColorRED);
+    source()->WaitForNextBackingStoreCopy();
+    ASSERT_TRUE(consumer()->WaitForNextColorOrError(SK_ColorRED));
+    source()->SetSolidColor(SK_ColorGREEN);
+    ASSERT_TRUE(consumer()->WaitForNextColorOrError(SK_ColorGREEN));
+    source()->SetSolidColor(SK_ColorBLUE);
+    ASSERT_TRUE(consumer()->WaitForNextColorOrError(SK_ColorBLUE));
+    source()->SetSolidColor(SK_ColorBLACK);
+    ASSERT_TRUE(consumer()->WaitForNextColorOrError(SK_ColorBLACK));
+  }
 
   device()->DeAllocate();
 }
 
 TEST_F(WebContentsVideoCaptureDeviceTest, RejectsInvalidAllocateParams) {
   device()->Allocate(1280, 720, -2, consumer());
   EXPECT_FALSE(consumer()->WaitForNextColorOrError(kNotInterested));
 }
 
 TEST_F(WebContentsVideoCaptureDeviceTest, BadFramesGoodFrames) {
@@ skipping 17 matching lines @@
   // Now push some good frames through; they should be processed normally.
   source()->SetCopyResultSize(kTestWidth, kTestHeight);
   source()->SetSolidColor(SK_ColorGREEN);
   EXPECT_TRUE(consumer()->WaitForNextColorOrError(SK_ColorGREEN));
   source()->SetSolidColor(SK_ColorRED);
   EXPECT_TRUE(consumer()->WaitForNextColorOrError(SK_ColorRED));
   device()->DeAllocate();
 }
 
 }  // namespace content