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;
@@ skipping 119 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 "
+                           << (use_video_frames ? "VideoFrame" : "SkBitmap")
+                           << " path, iteration #" << i);
+    // TODO(nick): Implement this.
+    // 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