Added support for YUV videos to the software compositor.

cc/layer_tree_host_impl_unittest.cc

 // Copyright 2011 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 "config.h"
 
 #include "cc/layer_tree_host_impl.h"
 
+#include "base/bind.h"
 #include "base/command_line.h"
 #include "base/hash_tables.h"
 #include "cc/delegated_renderer_layer_impl.h"
 #include "cc/gl_renderer.h"
 #include "cc/heads_up_display_layer_impl.h"
 #include "cc/io_surface_layer_impl.h"
 #include "cc/layer_impl.h"
 #include "cc/layer_tiling_data.h"
 #include "cc/quad_sink.h"
 #include "cc/render_pass_draw_quad.h"
 #include "cc/scrollbar_geometry_fixed_thumb.h"
 #include "cc/scrollbar_layer_impl.h"
 #include "cc/settings.h"
 #include "cc/single_thread_proxy.h"
 #include "cc/solid_color_draw_quad.h"
 #include "cc/test/animation_test_common.h"
 #include "cc/test/fake_web_compositor_output_surface.h"
 #include "cc/test/fake_web_graphics_context_3d.h"
 #include "cc/test/fake_web_scrollbar_theme_geometry.h"
 #include "cc/test/geometry_test_utils.h"
 #include "cc/test/layer_test_common.h"
 #include "cc/test/render_pass_test_common.h"
 #include "cc/test/test_common.h"
 #include "cc/texture_draw_quad.h"
 #include "cc/texture_layer_impl.h"
 #include "cc/tile_draw_quad.h"
 #include "cc/tiled_layer_impl.h"
 #include "cc/video_layer_impl.h"
+#include "media/base/media.h"
+#include "media/base/video_frame.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include <public/WebVideoFrame.h>
 #include <public/WebVideoFrameProvider.h>
 
 using namespace cc;
 using namespace LayerTestCommon;
 using namespace WebKit;
 using namespace WebKitTests;
 
+using media::VideoFrame;
 using ::testing::Mock;
 using ::testing::Return;
 using ::testing::AnyNumber;
 using ::testing::AtLeast;
 using ::testing::_;
 
 namespace {
 
 // This test is parametrized to run all tests with the
 // Settings::pageScalePinchZoomEnabled field enabled and disabled.
 class LayerTreeHostImplTest : public testing::TestWithParam<bool>,
                                 public LayerTreeHostImplClient {
 public:
     LayerTreeHostImplTest()
         : m_onCanDrawStateChangedCalled(false)
         , m_didRequestCommit(false)
         , m_didRequestRedraw(false)
         , m_reduceMemoryResult(true)
     {
+        media::InitializeMediaLibraryForTesting();
     }
 
     virtual void SetUp()
     {
         Settings::setPageScalePinchZoomEnabled(GetParam());
         LayerTreeSettings settings;
         settings.minimumOcclusionTrackingSize = IntSize();
 
         m_hostImpl = LayerTreeHostImpl::create(settings, this);
         m_hostImpl->initializeRenderer(createContext());
@@ skipping 2449 matching lines @@
     virtual void bindTexture(WGC3Denum, WebGLId id)
     {
         if (id && !ContainsKey(m_allocatedTextureIds, id))
             ADD_FAILURE() << "Trying to bind texture id " << id;
     }
 
 private:
     base::hash_set<unsigned> m_allocatedTextureIds;
 };
 
-// Fake video frame that represents a 4x4 YUV video frame.
+// Fake WebVideoFrame wrapper of media::VideoFrame.
 class FakeVideoFrame: public WebVideoFrame {
 public:
-    FakeVideoFrame() : m_textureId(0) { memset(m_data, 0x80, sizeof(m_data)); }
+    explicit FakeVideoFrame(const scoped_refptr<VideoFrame>& frame) : m_frame(frame) { }
     virtual ~FakeVideoFrame() { }
-    virtual Format format() const { return m_textureId ? FormatNativeTexture : FormatYV12; }
-    virtual unsigned width() const { return 4; }
-    virtual unsigned height() const { return 4; }
-    virtual unsigned planes() const { return m_textureId ? 0 : 3; }
-    virtual int stride(unsigned plane) const { return 4; }
-    virtual const void* data(unsigned plane) const { return m_data; }
-    virtual unsigned textureId() const { return m_textureId; }
-    virtual unsigned textureTarget() const { return m_textureId ? GL_TEXTURE_2D : 0; }
 
-    void setTextureId(unsigned id) { m_textureId = id; }
+    virtual Format format() const { NOTREACHED(); return FormatInvalid; }
+    virtual unsigned width() const { NOTREACHED(); return 0; }
+    virtual unsigned height() const { NOTREACHED(); return 0; }
+    virtual unsigned planes() const { NOTREACHED(); return 0; }
+    virtual int stride(unsigned plane) const { NOTREACHED(); return 0; }
+    virtual const void* data(unsigned plane) const { NOTREACHED(); return NULL; }
+    virtual unsigned textureId() const { NOTREACHED(); return 0; }
+    virtual unsigned textureTarget() const { NOTREACHED(); return 0; }
+
+    static VideoFrame* toVideoFrame(WebVideoFrame* web_video_frame) {
+        FakeVideoFrame* wrapped_frame =
+            static_cast<FakeVideoFrame*>(web_video_frame);
+        if (wrapped_frame)
+            return wrapped_frame->m_frame.get();
+        return NULL;
+    }
 
 private:
-    char m_data[16];
-    unsigned m_textureId;
+    scoped_refptr<VideoFrame> m_frame;
 };
 
 // Fake video frame provider that always provides the same FakeVideoFrame.
 class FakeVideoFrameProvider: public WebVideoFrameProvider {
 public:
     FakeVideoFrameProvider() : m_frame(0), m_client(0) { }
     virtual ~FakeVideoFrameProvider()
     {
         if (m_client)
             m_client->stopUsingProvider();
@@ skipping 124 matching lines @@
 
     scoped_ptr<TextureLayerImpl> textureLayerWithMask = TextureLayerImpl::create(layerId++);
     textureLayerWithMask->setBounds(IntSize(10, 10));
     textureLayerWithMask->setAnchorPoint(FloatPoint(0, 0));
     textureLayerWithMask->setContentBounds(IntSize(10, 10));
     textureLayerWithMask->setDrawsContent(true);
     textureLayerWithMask->setTextureId(1);
     textureLayerWithMask->setMaskLayer(maskLayer.PassAs<LayerImpl>());
     rootLayer->addChild(textureLayerWithMask.PassAs<LayerImpl>());
 
-    FakeVideoFrame videoFrame;
+    FakeVideoFrame videoFrame(VideoFrame::CreateColorFrame(gfx::Size(4, 4),
+                                                           0x80, 0x80, 0x80,
+                                                           base::TimeDelta()));
+    VideoLayerImpl::FrameUnwrapper unwrapper =
+        base::Bind(FakeVideoFrame::toVideoFrame);
     FakeVideoFrameProvider provider;
     provider.setFrame(&videoFrame);
-    scoped_ptr<VideoLayerImpl> videoLayer = VideoLayerImpl::create(layerId++, &provider);
+    scoped_ptr<VideoLayerImpl> videoLayer =
+        VideoLayerImpl::create(layerId++, &provider, unwrapper);
     videoLayer->setBounds(IntSize(10, 10));
     videoLayer->setAnchorPoint(FloatPoint(0, 0));
     videoLayer->setContentBounds(IntSize(10, 10));
     videoLayer->setDrawsContent(true);
     videoLayer->setLayerTreeHostImpl(m_hostImpl.get());
     rootLayer->addChild(videoLayer.PassAs<LayerImpl>());
 
-    FakeVideoFrame hwVideoFrame;
     FakeVideoFrameProvider hwProvider;
-    hwProvider.setFrame(&hwVideoFrame);
-    scoped_ptr<VideoLayerImpl> hwVideoLayer = VideoLayerImpl::create(layerId++, &hwProvider);
+    scoped_ptr<VideoLayerImpl> hwVideoLayer =
+        VideoLayerImpl::create(layerId++, &hwProvider, unwrapper);
     hwVideoLayer->setBounds(IntSize(10, 10));
     hwVideoLayer->setAnchorPoint(FloatPoint(0, 0));
     hwVideoLayer->setContentBounds(IntSize(10, 10));
     hwVideoLayer->setDrawsContent(true);
     hwVideoLayer->setLayerTreeHostImpl(m_hostImpl.get());
     rootLayer->addChild(hwVideoLayer.PassAs<LayerImpl>());
 
     scoped_ptr<IOSurfaceLayerImpl> ioSurfaceLayer = IOSurfaceLayerImpl::create(layerId++);
     ioSurfaceLayer->setBounds(IntSize(10, 10));
     ioSurfaceLayer->setAnchorPoint(FloatPoint(0, 0));
@@ skipping 26 matching lines @@
     delegatedRendererLayer->setLayerTreeHostImpl(m_hostImpl.get());
     ScopedPtrVector<RenderPass> passList;
     passList.append(createRenderPassWithResource(m_hostImpl->resourceProvider()));
     delegatedRendererLayer->setRenderPasses(passList);
     EXPECT_TRUE(passList.isEmpty());
     rootLayer->addChild(delegatedRendererLayer.PassAs<LayerImpl>());
 
     // Use a context that supports IOSurfaces
     m_hostImpl->initializeRenderer(FakeWebCompositorOutputSurface::create(scoped_ptr<WebKit::WebGraphicsContext3D>(new FakeWebGraphicsContext3DWithIOSurface)).PassAs<GraphicsContext>());
 
-    hwVideoFrame.setTextureId(m_hostImpl->resourceProvider()->graphicsContext3D()->createTexture());
+    FakeVideoFrame hwVideoFrame(
+        VideoFrame::WrapNativeTexture(
+            m_hostImpl->resourceProvider()->graphicsContext3D()->createTexture(),
+            GL_TEXTURE_2D,
+            gfx::Size(4, 4), gfx::Size(4, 4), base::TimeDelta(),
+            VideoFrame::ReadPixelsCB(), base::Closure()));
+    hwProvider.setFrame(&hwVideoFrame);
 
     m_hostImpl->setRootLayer(rootLayer.Pass());
 
     LayerTreeHostImpl::FrameData frame;
     EXPECT_TRUE(m_hostImpl->prepareToDraw(frame));
     m_hostImpl->drawLayers(frame);
     m_hostImpl->didDrawAllLayers(frame);
     m_hostImpl->swapBuffers();
 
     unsigned numResources = m_hostImpl->resourceProvider()->numResources();
 
     // Lose the context, replacing it with a StrictWebGraphicsContext3DWithIOSurface,
     // that will warn if any resource from the previous context gets used.
     m_hostImpl->initializeRenderer(FakeWebCompositorOutputSurface::create(scoped_ptr<WebKit::WebGraphicsContext3D>(new StrictWebGraphicsContext3DWithIOSurface)).PassAs<GraphicsContext>());
 
     // Create dummy resources so that looking up an old resource will get an
     // invalid texture id mapping.
     for (unsigned i = 0; i < numResources; ++i)
         m_hostImpl->resourceProvider()->createResourceFromExternalTexture(1);
 
     // The WebVideoFrameProvider is expected to recreate its textures after a
     // lost context (or not serve a frame).
     hwProvider.setFrame(0);
 
     EXPECT_TRUE(m_hostImpl->prepareToDraw(frame));
     m_hostImpl->drawLayers(frame);
     m_hostImpl->didDrawAllLayers(frame);
     m_hostImpl->swapBuffers();
 
-    hwVideoFrame.setTextureId(m_hostImpl->resourceProvider()->graphicsContext3D()->createTexture());
-    hwProvider.setFrame(&hwVideoFrame);
+    FakeVideoFrame hwVideoFrame2(
+        VideoFrame::WrapNativeTexture(
+            m_hostImpl->resourceProvider()->graphicsContext3D()->createTexture(),
+            GL_TEXTURE_2D,
+            gfx::Size(4, 4), gfx::Size(4, 4), base::TimeDelta(),
+            VideoFrame::ReadPixelsCB(), base::Closure()));
+    hwProvider.setFrame(&hwVideoFrame2);
 
     EXPECT_TRUE(m_hostImpl->prepareToDraw(frame));
     m_hostImpl->drawLayers(frame);
     m_hostImpl->didDrawAllLayers(frame);
     m_hostImpl->swapBuffers();
 }
 
 // Fake WebGraphicsContext3D that tracks the number of textures in use.
 class TrackingWebGraphicsContext3D : public FakeWebGraphicsContext3D {
 public:
@@ skipping 54 matching lines @@
     rootLayer->addChild(tileLayer.PassAs<LayerImpl>());
 
     scoped_ptr<TextureLayerImpl> textureLayer = TextureLayerImpl::create(3);
     textureLayer->setBounds(IntSize(10, 10));
     textureLayer->setAnchorPoint(FloatPoint(0, 0));
     textureLayer->setContentBounds(IntSize(10, 10));
     textureLayer->setDrawsContent(true);
     textureLayer->setTextureId(1);
     rootLayer->addChild(textureLayer.PassAs<LayerImpl>());
 
+    VideoLayerImpl::FrameUnwrapper unwrapper =
+        base::Bind(FakeVideoFrame::toVideoFrame);
     FakeVideoFrameProvider provider;
-    scoped_ptr<VideoLayerImpl> videoLayer = VideoLayerImpl::create(4, &provider);
+    scoped_ptr<VideoLayerImpl> videoLayer =
+        VideoLayerImpl::create(4, &provider, unwrapper);
     videoLayer->setBounds(IntSize(10, 10));
     videoLayer->setAnchorPoint(FloatPoint(0, 0));
     videoLayer->setContentBounds(IntSize(10, 10));
     videoLayer->setDrawsContent(true);
     videoLayer->setLayerTreeHostImpl(m_hostImpl.get());
     rootLayer->addChild(videoLayer.PassAs<LayerImpl>());
 
     scoped_ptr<IOSurfaceLayerImpl> ioSurfaceLayer = IOSurfaceLayerImpl::create(5);
     ioSurfaceLayer->setBounds(IntSize(10, 10));
     ioSurfaceLayer->setAnchorPoint(FloatPoint(0, 0));
@@ skipping 1498 matching lines @@
         verifyRenderPassTestData(removeRenderPassesCases[testCaseIndex], testData);
         testCaseIndex++;
     }
 }
 
 INSTANTIATE_TEST_CASE_P(LayerTreeHostImplTests,
                         LayerTreeHostImplTest,
                         ::testing::Values(false, true));
 
 } // namespace