Added support for YUV videos to the software compositor.

cc/software_renderer.cc

 // Copyright 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 "config.h"
 
 #include "cc/software_renderer.h"
 
 #include "cc/debug_border_draw_quad.h"
 #include "cc/render_pass_draw_quad.h"
 #include "cc/solid_color_draw_quad.h"
 #include "cc/texture_draw_quad.h"
 #include "cc/tile_draw_quad.h"
+#include "cc/video_frame_draw_quad.h"
+#include "media/filters/skcanvas_video_renderer.h"
 #include "third_party/skia/include/core/SkCanvas.h"
 #include "third_party/skia/include/core/SkColor.h"
 #include "third_party/skia/include/core/SkMatrix.h"
 #include "third_party/skia/include/core/SkShader.h"
 #include "third_party/skia/include/effects/SkLayerRasterizer.h"
 #include "ui/gfx/rect_conversions.h"
+#include <public/WebCompositorSoftwareOutputDevice.h>
 #include <public/WebImage.h>
 #include <public/WebSize.h>
 #include <public/WebTransformationMatrix.h>
 
 using WebKit::WebCompositorSoftwareOutputDevice;
-using WebKit::WebImage;
 using WebKit::WebSize;
 using WebKit::WebTransformationMatrix;
 
 namespace cc {
 
 namespace {
 
 SkRect toSkRect(const gfx::RectF& rect)
 {
     return SkRect::MakeXYWH(rect.x(), rect.y(), rect.width(), rect.height());
@@ skipping 172 matching lines @@
         break;
     case DrawQuad::TextureContent:
         drawTextureQuad(frame, TextureDrawQuad::materialCast(quad));
         break;
     case DrawQuad::TiledContent:
         drawTileQuad(frame, TileDrawQuad::materialCast(quad));
         break;
     case DrawQuad::RenderPass:
         drawRenderPassQuad(frame, RenderPassDrawQuad::materialCast(quad));
         break;
+    case DrawQuad::VideoFrameContent:
+        drawVideoFrameQuad(frame, VideoFrameDrawQuad::materialCast(quad));
+        break;
     default:
         drawUnsupportedQuad(frame, quad);
         break;
     }
 
     m_skCurrentCanvas->resetMatrix();
 }
 
 void SoftwareRenderer::drawDebugBorderQuad(const DrawingFrame& frame, const DebugBorderDrawQuad* quad)
 {
@@ skipping 89 matching lines @@
         maskRasterizer->addLayer(maskPaint);
 
         m_skCurrentPaint.setRasterizer(maskRasterizer);
         m_skCurrentCanvas->drawRect(destRect, m_skCurrentPaint);
     } else {
         // FIXME: Apply background filters and blend with contents
         m_skCurrentCanvas->drawRect(destRect, m_skCurrentPaint);
     }
 }
 
+void SoftwareRenderer::drawVideoFrameQuad(const DrawingFrame& frame, const VideoFrameDrawQuad* quad)
+{
+    if (!m_videoRenderer)
+        m_videoRenderer.reset(new media::SkCanvasVideoRenderer);
+    m_videoRenderer->Paint(quad->frame(), m_skCurrentCanvas, quadVertexRect(),
+                           quad->opacity() * 255);
+}
+
 void SoftwareRenderer::drawUnsupportedQuad(const DrawingFrame& frame, const DrawQuad* quad)
 {
     m_skCurrentPaint.setColor(SK_ColorMAGENTA);
     m_skCurrentPaint.setAlpha(quad->opacity() * 255);
     m_skCurrentCanvas->drawRect(toSkRect(quadVertexRect()), m_skCurrentPaint);
 }
 
 bool SoftwareRenderer::swapBuffers()
 {
     if (Proxy::hasImplThread())
@@ skipping 12 matching lines @@
 }
 
 void SoftwareRenderer::setVisible(bool visible)
 {
     if (m_visible == visible)
         return;
     m_visible = visible;
 }
 
 }