Send compositor frame IPC with metadata.

cc/gl_renderer.cc

 // Copyright 2010 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/gl_renderer.h"
 
 #include "base/debug/trace_event.h"
 #include "base/logging.h"
 #include "base/string_split.h"
 #include "base/string_util.h"
 #include "build/build_config.h"
+#include "cc/compositor_frame.h"
+#include "cc/compositor_frame_metadata.h"
 #include "cc/damage_tracker.h"
 #include "cc/geometry_binding.h"
+#include "cc/gl_frame_data.h"
 #include "cc/layer_quad.h"
 #include "cc/math_util.h"
 #include "cc/priority_calculator.h"
 #include "cc/proxy.h"
 #include "cc/render_pass.h"
 #include "cc/render_surface_filters.h"
 #include "cc/scoped_resource.h"
 #include "cc/single_thread_proxy.h"
 #include "cc/stream_video_draw_quad.h"
 #include "cc/texture_draw_quad.h"
@@ skipping 27 matching lines @@
 {
 #if defined(OS_MACOSX)
     return true;
 #else
     return false;
 #endif
 }
 
 } // anonymous namespace
 
-scoped_ptr<GLRenderer> GLRenderer::create(RendererClient* client, ResourceProvider* resourceProvider)
+scoped_ptr<GLRenderer> GLRenderer::create(RendererClient* client, OutputSurface* outputSurface, ResourceProvider* resourceProvider)
 {
-    scoped_ptr<GLRenderer> renderer(make_scoped_ptr(new GLRenderer(client, resourceProvider)));
+    scoped_ptr<GLRenderer> renderer(make_scoped_ptr(new GLRenderer(client, outputSurface, resourceProvider)));
     if (!renderer->initialize())
         return scoped_ptr<GLRenderer>();
 
     return renderer.Pass();
 }
 
-GLRenderer::GLRenderer(RendererClient* client, ResourceProvider* resourceProvider)
+GLRenderer::GLRenderer(RendererClient* client, OutputSurface* outputSurface, ResourceProvider* resourceProvider)
     : DirectRenderer(client, resourceProvider)
     , m_offscreenFramebufferId(0)
     , m_sharedGeometryQuad(gfx::RectF(-0.5f, -0.5f, 1.0f, 1.0f))
-    , m_context(resourceProvider->graphicsContext3D())
+    , m_outputSurface(outputSurface)
+    , m_context(outputSurface->Context3D())
     , m_isViewportChanged(false)
     , m_isBackbufferDiscarded(false)
     , m_discardBackbufferWhenNotVisible(false)
     , m_isUsingBindUniform(false)
     , m_visible(true)
     , m_isScissorEnabled(false)
 {
     DCHECK(m_context);
 }
 
@@ skipping 1066 matching lines @@
     GLC(context(), context()->bindTexture(GL_TEXTURE_RECTANGLE_ARB, 0));
 }
 
 void GLRenderer::finishDrawingFrame(DrawingFrame& frame)
 {
     m_currentFramebufferLock.reset();
     m_swapBufferRect.Union(gfx::ToEnclosingRect(frame.rootDamageRect));
 
     GLC(m_context, m_context->disable(GL_BLEND));
     m_blendShadow = false;
+
+    if (settings().compositorFrameMessage) {
+        CompositorFrame compositor_frame;
+        compositor_frame.metadata = m_client->makeCompositorFrameMetadata();
+        compositor_frame.gl_frame_data.reset(new GLFrameData());
+        // FIXME: Fill in GLFrameData when we implement swapping with it.
+        m_outputSurface->SendFrameToParentCompositor(compositor_frame);
+    }
 }
 
 void GLRenderer::finishDrawingQuadList()
 {
     flushTextureQuadCache();
 }
 
 bool GLRenderer::flippedFramebuffer() const
 {
     return true;
@@ skipping 604 matching lines @@
 
     releaseRenderPassTextures();
 }
 
 bool GLRenderer::isContextLost()
 {
     return (m_context->getGraphicsResetStatusARB() != GL_NO_ERROR);
 }
 
 }  // namespace cc