Move VideoFrameProvider to, and remove all usage of WebVideoFrame from cc/

cc/video_layer_impl.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 "cc/video_layer_impl.h"
 
 #include "base/logging.h"
 #include "cc/io_surface_draw_quad.h"
 #include "cc/layer_tree_impl.h"
 #include "cc/math_util.h"
 #include "cc/quad_sink.h"
 #include "cc/renderer.h"
 #include "cc/resource_provider.h"
 #include "cc/stream_video_draw_quad.h"
 #include "cc/texture_draw_quad.h"
 #include "cc/yuv_video_draw_quad.h"
 #include "media/filters/skcanvas_video_renderer.h"
 #include "third_party/khronos/GLES2/gl2.h"
 #include "third_party/khronos/GLES2/gl2ext.h"
 
 namespace cc {
 
-VideoLayerImpl::VideoLayerImpl(LayerTreeImpl* treeImpl, int id, WebKit::WebVideoFrameProvider* provider,
-                               const FrameUnwrapper& unwrapper)
+VideoLayerImpl::VideoLayerImpl(LayerTreeImpl* treeImpl, int id, VideoFrameProvider* provider)
     : LayerImpl(treeImpl, id)
     , m_provider(provider)
-    , m_unwrapper(unwrapper)
-    , m_webFrame(0)
     , m_frame(0)
     , m_format(GL_INVALID_VALUE)
     , m_convertYUV(false)
     , m_externalTextureResource(0)
 {
     // This matrix is the default transformation for stream textures, and flips on the Y axis.
     m_streamTextureMatrix = MathUtil::createGfxTransform(
         1, 0, 0, 0,
         0, -1, 0, 0,
         0, 0, 1, 0,
         0, 1, 0, 1);
 
     // This only happens during a commit on the compositor thread while the main
     // thread is blocked. That makes this a thread-safe call to set the video
     // frame provider client that does not require a lock. The same is true of
     // the call in the destructor.
-    m_provider->setVideoFrameProviderClient(this);
+    m_provider->SetVideoFrameProviderClient(this);
 }
 
 VideoLayerImpl::~VideoLayerImpl()
 {
     // See comment in constructor for why this doesn't need a lock.
     if (m_provider) {
-        m_provider->setVideoFrameProviderClient(0);
+        m_provider->SetVideoFrameProviderClient(0);
         m_provider = 0;
     }
     freePlaneData(layerTreeImpl()->resource_provider());
 
 #ifndef NDEBUG
     for (size_t i = 0; i < media::VideoFrame::kMaxPlanes; ++i)
         DCHECK(!m_framePlanes[i].resourceId);
     DCHECK(!m_externalTextureResource);
 #endif
 }
 
-void VideoLayerImpl::stopUsingProvider()
+void VideoLayerImpl::StopUsingProvider()
 {
     // Block the provider from shutting down until this client is done
     // using the frame.
     base::AutoLock locker(m_providerLock);
     DCHECK(!m_frame);
     m_provider = 0;
 }
 
 // Convert media::VideoFrame::Format to OpenGL enum values.
 static GLenum convertVFCFormatToGLenum(const media::VideoFrame& frame)
@@ skipping 61 matching lines @@
 
 void VideoLayerImpl::willDrawInternal(ResourceProvider* resourceProvider)
 {
     DCHECK(!m_externalTextureResource);
 
     if (!m_provider) {
         m_frame = 0;
         return;
     }
 
-    m_webFrame = m_provider->getCurrentFrame();
-    m_frame = m_unwrapper.Run(m_webFrame);
+    m_frame = m_provider->GetCurrentFrame();
 
     if (!m_frame)
         return;
 
     m_format = convertVFCFormatToGLenum(*m_frame);
 
     // If these fail, we'll have to add draw logic that handles offset bitmap/
     // texture UVs.  For now, just expect (0, 0) offset, since all our decoders
     // so far don't offset.
     DCHECK_EQ(m_frame->visible_rect().x(), 0);
     DCHECK_EQ(m_frame->visible_rect().y(), 0);
 
     if (m_format == GL_INVALID_VALUE) {
-        m_provider->putCurrentFrame(m_webFrame);
+        m_provider->PutCurrentFrame(m_frame);
         m_frame = 0;
         return;
     }
 
     // FIXME: If we're in software compositing mode, we do the YUV -> RGB
     // conversion here. That involves an extra copy of each frame to a bitmap.
     // Obviously, this is suboptimal and should be addressed once ubercompositor
     // starts shaping up.
     m_convertYUV = resourceProvider->defaultResourceType() == ResourceProvider::Bitmap &&
         (m_frame->format() == media::VideoFrame::YV12 ||
          m_frame->format() == media::VideoFrame::YV16);
 
     if (m_convertYUV)
         m_format = GL_RGBA;
 
     if (!allocatePlaneData(resourceProvider)) {
-        m_provider->putCurrentFrame(m_webFrame);
+        m_provider->PutCurrentFrame(m_frame);
         m_frame = 0;
         return;
     }
 
     if (!copyPlaneData(resourceProvider)) {
-        m_provider->putCurrentFrame(m_webFrame);
+        m_provider->PutCurrentFrame(m_frame);
         m_frame = 0;
         return;
     }
 
     if (m_format == GL_TEXTURE_2D)
         m_externalTextureResource = resourceProvider->createResourceFromExternalTexture(m_frame->texture_id());
 }
 
 void VideoLayerImpl::appendQuads(QuadSink& quadSink, AppendQuadsData& appendQuadsData)
 {
@@ skipping 84 matching lines @@
     if (m_format == GL_TEXTURE_2D) {
         DCHECK(m_externalTextureResource);
         // FIXME: the following assert will not be true when sending resources to a
         // parent compositor. We will probably need to hold on to m_frame for
         // longer, and have several "current frames" in the pipeline.
         DCHECK(!resourceProvider->inUseByConsumer(m_externalTextureResource));
         resourceProvider->deleteResource(m_externalTextureResource);
         m_externalTextureResource = 0;
     }
 
-    m_provider->putCurrentFrame(m_webFrame);
+    m_provider->PutCurrentFrame(m_frame);
     m_frame = 0;
 
     m_providerLock.Release();
 }
 
 static gfx::Size videoFrameDimension(media::VideoFrame* frame, int plane) {
     gfx::Size dimensions = frame->coded_size();
     switch (frame->format()) {
     case media::VideoFrame::YV12:
         if (plane != media::VideoFrame::kYPlane) {
@@ skipping 91 matching lines @@
         m_framePlanes[i].freeData(resourceProvider);
 }
 
 void VideoLayerImpl::freeUnusedPlaneData(ResourceProvider* resourceProvider)
 {
     size_t firstUnusedPlane = numPlanes();
     for (size_t i = firstUnusedPlane; i < media::VideoFrame::kMaxPlanes; ++i)
         m_framePlanes[i].freeData(resourceProvider);
 }
 
-void VideoLayerImpl::didReceiveFrame()
+void VideoLayerImpl::DidReceiveFrame()
 {
     setNeedsRedraw();
 }
 
-void VideoLayerImpl::didUpdateMatrix(const float matrix[16])
+void VideoLayerImpl::DidUpdateMatrix(const float matrix[16])
 {
     m_streamTextureMatrix = MathUtil::createGfxTransform(
         matrix[0], matrix[1], matrix[2], matrix[3],
         matrix[4], matrix[5], matrix[6], matrix[7],
         matrix[8], matrix[9], matrix[10], matrix[11],
         matrix[12], matrix[13], matrix[14], matrix[15]);
     setNeedsRedraw();
 }
 
 void VideoLayerImpl::didLoseOutputSurface()
 {
     freePlaneData(layerTreeImpl()->resource_provider());
 }
 
 void VideoLayerImpl::setNeedsRedraw()
 {
     layerTreeImpl()->SetNeedsRedraw();
 }
 
 const char* VideoLayerImpl::layerTypeAsString() const
 {
     return "VideoLayer";
 }
 
 }  // namespace cc