cc: Chromify Layer and LayerImpl classes.

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/video_frame_provider_client_impl.h"
 #include "cc/yuv_video_draw_quad.h"
 #include "gpu/GLES2/gl2extchromium.h"
 #include "media/filters/skcanvas_video_renderer.h"
 #include "third_party/khronos/GLES2/gl2.h"
 #include "third_party/khronos/GLES2/gl2ext.h"
 
 #if defined(GOOGLE_TV)
 #include "cc/solid_color_draw_quad.h"
 #endif
 
 namespace cc {
 
 // static
-scoped_ptr<VideoLayerImpl> VideoLayerImpl::create(LayerTreeImpl* treeImpl, int id, VideoFrameProvider* provider)
+scoped_ptr<VideoLayerImpl> VideoLayerImpl::Create(LayerTreeImpl* treeImpl, int id, VideoFrameProvider* provider)
 {
     scoped_ptr<VideoLayerImpl> layer(new VideoLayerImpl(treeImpl, id));
     layer->setProviderClientImpl(VideoFrameProviderClientImpl::Create(provider));
     DCHECK(treeImpl->proxy()->IsImplThread());
     DCHECK(treeImpl->proxy()->IsMainThreadBlocked());
     return layer.Pass();
 }
 
 VideoLayerImpl::VideoLayerImpl(LayerTreeImpl* treeImpl, int id)
     : LayerImpl(treeImpl, id)
     , m_frame(0)
     , m_format(GL_INVALID_VALUE)
     , m_convertYUV(false)
     , m_externalTextureResource(0)
 {
 }
 
 VideoLayerImpl::~VideoLayerImpl()
 {
     if (!m_providerClientImpl->Stopped()) {
         // In impl side painting, we may have a pending and active layer
         // associated with the video provider at the same time. Both have a ref
         // on the VideoFrameProviderClientImpl, but we stop when the first
         // LayerImpl (the one on the pending tree) is destroyed since we know
         // the main thread is blocked for this commit.
-        DCHECK(layerTreeImpl()->proxy()->IsImplThread());
-        DCHECK(layerTreeImpl()->proxy()->IsMainThreadBlocked());
+        DCHECK(layer_tree_impl()->proxy()->IsImplThread());
+        DCHECK(layer_tree_impl()->proxy()->IsMainThreadBlocked());
         m_providerClientImpl->Stop();
     }
-    freePlaneData(layerTreeImpl()->resource_provider());
+    freePlaneData(layer_tree_impl()->resource_provider());
 
 #ifndef NDEBUG
     for (size_t i = 0; i < media::VideoFrame::kMaxPlanes; ++i)
         DCHECK(!m_framePlanes[i].resourceId);
     DCHECK(!m_externalTextureResource);
 #endif
 }
 
-scoped_ptr<LayerImpl> VideoLayerImpl::createLayerImpl(LayerTreeImpl* treeImpl)
+scoped_ptr<LayerImpl> VideoLayerImpl::CreateLayerImpl(LayerTreeImpl* treeImpl)
 {
     return scoped_ptr<LayerImpl>(new VideoLayerImpl(treeImpl, id()));
 }
 
-void VideoLayerImpl::pushPropertiesTo(LayerImpl* layer)
+void VideoLayerImpl::PushPropertiesTo(LayerImpl* layer)
 {
-    LayerImpl::pushPropertiesTo(layer);
+    LayerImpl::PushPropertiesTo(layer);
 
     VideoLayerImpl* other = static_cast<VideoLayerImpl*>(layer);
     other->setProviderClientImpl(m_providerClientImpl);
 }
 
-void VideoLayerImpl::didBecomeActive()
+void VideoLayerImpl::DidBecomeActive()
 {
     m_providerClientImpl->set_active_video_layer(this);
 }
 
 // Convert media::VideoFrame::Format to OpenGL enum values.
 static GLenum convertVFCFormatToGLenum(const media::VideoFrame& frame)
 {
     switch (frame.format()) {
     case media::VideoFrame::YV12:
     case media::VideoFrame::YV16:
@@ skipping 18 matching lines @@
 {
     if (!m_frame)
         return 0;
 
     if (m_convertYUV)
         return 1;
 
     return media::VideoFrame::NumPlanes(m_frame->format());
 }
 
-void VideoLayerImpl::willDraw(ResourceProvider* resourceProvider)
+void VideoLayerImpl::WillDraw(ResourceProvider* resourceProvider)
 {
-    LayerImpl::willDraw(resourceProvider);
+    LayerImpl::WillDraw(resourceProvider);
 
 
     // Explicitly acquire and release the provider mutex so it can be held from
     // willDraw to didDraw. Since the compositor thread is in the middle of
     // drawing, the layer will not be destroyed before didDraw is called.
     // Therefore, the only thing that will prevent this lock from being released
     // is the GPU process locking it. As the GPU process can't cause the
     // destruction of the provider (calling stopUsingProvider), holding this
     // lock should not cause a deadlock.
     m_frame = m_providerClientImpl->AcquireLockAndCurrentFrame();
@@ skipping 51 matching lines @@
     if (!copyPlaneData(resourceProvider)) {
         m_providerClientImpl->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)
+void VideoLayerImpl::AppendQuads(QuadSink* quadSink, AppendQuadsData* appendQuadsData)
 {
     if (!m_frame)
         return;
 
-    SharedQuadState* sharedQuadState = quadSink.useSharedQuadState(createSharedQuadState());
-    appendDebugBorderQuad(quadSink, sharedQuadState, appendQuadsData);
+    SharedQuadState* sharedQuadState = quadSink->useSharedQuadState(CreateSharedQuadState());
+    AppendDebugBorderQuad(quadSink, sharedQuadState, appendQuadsData);
 
     // FIXME: When we pass quads out of process, we need to double-buffer, or
     // otherwise synchonize use of all textures in the quad.
 
-    gfx::Rect quadRect(gfx::Point(), contentBounds());
-    gfx::Rect opaqueRect(contentsOpaque() ? quadRect : gfx::Rect());
+    gfx::Rect quadRect(content_bounds());
+    gfx::Rect opaqueRect(contents_opaque() ? quadRect : gfx::Rect());
     gfx::Rect visibleRect = m_frame->visible_rect();
     gfx::Size codedSize = m_frame->coded_size();
 
     // pixels for macroblocked formats.
     const float texWidthScale =
         static_cast<float>(visibleRect.width()) / codedSize.width();
     const float texHeightScale =
         static_cast<float>(visibleRect.height()) / codedSize.height();
 
 #if defined(GOOGLE_TV)
     // This block and other blocks wrapped around #if defined(GOOGLE_TV) is not
     // maintained by the general compositor team. Please contact the following
     // people instead:
     //
     // wonsik@chromium.org
     // ycheo@chromium.org
 
     if (m_frame->format() == media::VideoFrame::HOLE) {
         scoped_ptr<SolidColorDrawQuad> solidColorDrawQuad =
             SolidColorDrawQuad::Create();
         // Create a solid color quad with transparent black and force no
         // blending.
         solidColorDrawQuad->SetAll(
             sharedQuadState, quadRect, quadRect, quadRect, false,
             SK_ColorTRANSPARENT);
-        quadSink.append(solidColorDrawQuad.PassAs<DrawQuad>(), appendQuadsData);
+        quadSink->append(solidColorDrawQuad.PassAs<DrawQuad>(), appendQuadsData);
         return;
     }
 #endif
 
     switch (m_format) {
     case GL_LUMINANCE: {
         // YUV software decoder.
         const FramePlane& yPlane = m_framePlanes[media::VideoFrame::kYPlane];
         const FramePlane& uPlane = m_framePlanes[media::VideoFrame::kUPlane];
         const FramePlane& vPlane = m_framePlanes[media::VideoFrame::kVPlane];
         gfx::SizeF texScale(texWidthScale, texHeightScale);
         scoped_ptr<YUVVideoDrawQuad> yuvVideoQuad = YUVVideoDrawQuad::Create();
         yuvVideoQuad->SetNew(sharedQuadState, quadRect, opaqueRect, texScale, yPlane, uPlane, vPlane);
-        quadSink.append(yuvVideoQuad.PassAs<DrawQuad>(), appendQuadsData);
+        quadSink->append(yuvVideoQuad.PassAs<DrawQuad>(), appendQuadsData);
         break;
     }
     case GL_RGBA: {
         // RGBA software decoder.
         const FramePlane& plane = m_framePlanes[media::VideoFrame::kRGBPlane];
         bool premultipliedAlpha = true;
         gfx::PointF uvTopLeft(0.f, 0.f);
         gfx::PointF uvBottomRight(texWidthScale, texHeightScale);
         const float opacity[] = {1.0f, 1.0f, 1.0f, 1.0f};
         bool flipped = false;
         scoped_ptr<TextureDrawQuad> textureQuad = TextureDrawQuad::Create();
         textureQuad->SetNew(sharedQuadState, quadRect, opaqueRect, plane.resourceId, premultipliedAlpha, uvTopLeft, uvBottomRight, opacity, flipped);
-        quadSink.append(textureQuad.PassAs<DrawQuad>(), appendQuadsData);
+        quadSink->append(textureQuad.PassAs<DrawQuad>(), appendQuadsData);
         break;
     }
     case GL_TEXTURE_2D: {
         // NativeTexture hardware decoder.
         bool premultipliedAlpha = true;
         gfx::PointF uvTopLeft(0.f, 0.f);
         gfx::PointF uvBottomRight(texWidthScale, texHeightScale);
         const float opacity[] = {1.0f, 1.0f, 1.0f, 1.0f};
         bool flipped = false;
         scoped_ptr<TextureDrawQuad> textureQuad = TextureDrawQuad::Create();
         textureQuad->SetNew(sharedQuadState, quadRect, opaqueRect, m_externalTextureResource, premultipliedAlpha, uvTopLeft, uvBottomRight, opacity, flipped);
-        quadSink.append(textureQuad.PassAs<DrawQuad>(), appendQuadsData);
+        quadSink->append(textureQuad.PassAs<DrawQuad>(), appendQuadsData);
         break;
     }
     case GL_TEXTURE_RECTANGLE_ARB: {
         gfx::Size visibleSize(visibleRect.width(), visibleRect.height());
         scoped_ptr<IOSurfaceDrawQuad> ioSurfaceQuad = IOSurfaceDrawQuad::Create();
         ioSurfaceQuad->SetNew(sharedQuadState, quadRect, opaqueRect, visibleSize, m_frame->texture_id(), IOSurfaceDrawQuad::UNFLIPPED);
-        quadSink.append(ioSurfaceQuad.PassAs<DrawQuad>(), appendQuadsData);
+        quadSink->append(ioSurfaceQuad.PassAs<DrawQuad>(), appendQuadsData);
         break;
     }
     case GL_TEXTURE_EXTERNAL_OES: {
         // StreamTexture hardware decoder.
         gfx::Transform transform(m_providerClientImpl->stream_texture_matrix());
         transform.Scale(texWidthScale, texHeightScale);
         scoped_ptr<StreamVideoDrawQuad> streamVideoQuad = StreamVideoDrawQuad::Create();
         streamVideoQuad->SetNew(sharedQuadState, quadRect, opaqueRect, m_frame->texture_id(), transform);
-        quadSink.append(streamVideoQuad.PassAs<DrawQuad>(), appendQuadsData);
+        quadSink->append(streamVideoQuad.PassAs<DrawQuad>(), appendQuadsData);
         break;
     }
     default:
         NOTREACHED();  // Someone updated convertVFCFormatToGLenum above but update this!
         break;
     }
 }
 
-void VideoLayerImpl::didDraw(ResourceProvider* resourceProvider)
+void VideoLayerImpl::DidDraw(ResourceProvider* resourceProvider)
 {
-    LayerImpl::didDraw(resourceProvider);
+    LayerImpl::DidDraw(resourceProvider);
 
     if (!m_frame)
         return;
 
     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));
@@ skipping 106 matching lines @@
         m_framePlanes[i].freeData(resourceProvider);
 }
 
 void VideoLayerImpl::freeUnusedPlaneData(ResourceProvider* resourceProvider)
 {
     const size_t firstUnusedPlane = numPlanes();
     for (size_t i = firstUnusedPlane; i < media::VideoFrame::kMaxPlanes; ++i)
         m_framePlanes[i].freeData(resourceProvider);
 }
 
-void VideoLayerImpl::didLoseOutputSurface()
+void VideoLayerImpl::DidLoseOutputSurface()
 {
-    freePlaneData(layerTreeImpl()->resource_provider());
+    freePlaneData(layer_tree_impl()->resource_provider());
 }
 
 void VideoLayerImpl::setNeedsRedraw()
 {
-    layerTreeImpl()->SetNeedsRedraw();
+    layer_tree_impl()->SetNeedsRedraw();
 }
 
 void VideoLayerImpl::setProviderClientImpl(scoped_refptr<VideoFrameProviderClientImpl> providerClientImpl)
 {
     m_providerClientImpl = providerClientImpl;
 }
 
-const char* VideoLayerImpl::layerTypeAsString() const
+const char* VideoLayerImpl::LayerTypeAsString() const
 {
     return "VideoLayer";
 }
 
 }  // namespace cc