Send compositor frame IPC with metadata.

This makes CompositorFrame contain one of two payloads: DelegatedFrameData for ubercomp and GLFrameData for the Aura model.  This also adds CompositorFrameMetadata containing information useful for positioning subwindows relative to the webpage scroll position.

The message is sent when a new switch --enable-compositor-frame-message is set.  This is enabled by default on Android and also suppresses Android-specific UpdateFrameInfo messages, which will be superceded by CompositorFrameMetadata.

BUG=152337,161945

Review URL: https://chromiumcodereview.appspot.com/11316128

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@173634 0039d316-1c4b-4281-b951-d872f2087c98

34 files changed, 412 insertions, 66 deletions

diff --git a/cc/cc.gyp b/cc/cc.gyp
index 041864d..7caacff 100644
--- a/cc/cc.gyp
+++ b/cc/cc.gyp
@@ -24,6 +24,8 @@
       'compositor_frame.h',
       'compositor_frame_ack.cc',
       'compositor_frame_ack.h',
+      'compositor_frame_metadata.cc',
+      'compositor_frame_metadata.h',
       'content_layer.cc',
       'content_layer.h',
       'content_layer_client.h',
@@ -41,6 +43,8 @@
       'debug_rect_history.h',
       'delay_based_time_source.cc',
       'delay_based_time_source.h',
+      'delegated_frame_data.h',
+      'delegated_frame_data.cc',
       'delegated_renderer_layer.cc',
       'delegated_renderer_layer.h',
       'delegated_renderer_layer_impl.cc',
@@ -60,6 +64,8 @@
       'frame_rate_counter.h',
       'geometry_binding.cc',
       'geometry_binding.h',
+      'gl_frame_data.h',
+      'gl_frame_data.cc',
       'gl_renderer.cc',
       'gl_renderer.h',
       'gl_renderer_draw_cache.cc',
diff --git a/cc/compositor_frame.h b/cc/compositor_frame.h
index b9f09c1..88ebe2f 100644
--- a/cc/compositor_frame.h
+++ b/cc/compositor_frame.h
@@ -5,11 +5,11 @@
 #ifndef CC_COMPOSITOR_FRAME_H_
 #define CC_COMPOSITOR_FRAME_H_
 
+#include "base/memory/scoped_ptr.h"
 #include "cc/cc_export.h"
-#include "cc/render_pass.h"
-#include "cc/scoped_ptr_vector.h"
-#include "cc/transferable_resource.h"
-#include "ui/gfx/size.h"
+#include "cc/compositor_frame_metadata.h"
+#include "cc/delegated_frame_data.h"
+#include "cc/gl_frame_data.h"
 
 namespace cc {
 
@@ -18,9 +18,9 @@ class CC_EXPORT CompositorFrame {
   CompositorFrame();
   ~CompositorFrame();
 
-  gfx::Size size;
-  TransferableResourceList resource_list;
-  ScopedPtrVector<RenderPass> render_pass_list;
+  CompositorFrameMetadata metadata;
+  scoped_ptr<DelegatedFrameData> delegated_frame_data;
+  scoped_ptr<GLFrameData> gl_frame_data;
 };
 
 }  // namespace cc
diff --git a/cc/compositor_frame_metadata.cc b/cc/compositor_frame_metadata.cc
new file mode 100644
index 0000000..acc8178
--- /dev/null
+++ b/cc/compositor_frame_metadata.cc
@@ -0,0 +1,18 @@
+// Copyright (c) 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 "cc/compositor_frame_metadata.h"
+
+namespace cc {
+
+CompositorFrameMetadata::CompositorFrameMetadata()
+    : page_scale_factor(0),
+      min_page_scale_factor(0),
+      max_page_scale_factor(0) {
+}
+
+CompositorFrameMetadata::~CompositorFrameMetadata() {
+}
+
+}  // namespace cc
diff --git a/cc/compositor_frame_metadata.h b/cc/compositor_frame_metadata.h
new file mode 100644
index 0000000..92a48ff
--- /dev/null
+++ b/cc/compositor_frame_metadata.h
@@ -0,0 +1,39 @@
+// Copyright (c) 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.
+
+#ifndef CC_COMPOSITOR_FRAME_METADATA_H_
+#define CC_COMPOSITOR_FRAME_METADATA_H_
+
+#include "cc/cc_export.h"
+#include "ui/gfx/size_f.h"
+#include "ui/gfx/vector2d_f.h"
+
+namespace cc {
+
+class CC_EXPORT CompositorFrameMetadata
+{
+ public:
+  CompositorFrameMetadata();
+  ~CompositorFrameMetadata();
+
+  // Scroll offset and scale of the root layer. This can be used for tasks
+  // like positioning windowed plugins.
+  gfx::Vector2dF root_scroll_offset;
+  float page_scale_factor;
+
+  // These limits can be used together with the scroll/scale fields above to
+  // determine if scrolling/scaling in a particular direction is possible.
+  gfx::SizeF viewport_size;
+  gfx::SizeF root_layer_size;
+  float min_page_scale_factor;
+  float max_page_scale_factor;
+
+  // Used to position the Android location top bar, whose precise
+  // position is computed by the renderer compositor.
+  gfx::Vector2dF location_bar_offset;
+};
+
+}  // namespace cc
+
+#endif  // CC_COMPOSITOR_FRAME_METADATA_H_
diff --git a/cc/delegated_frame_data.cc b/cc/delegated_frame_data.cc
new file mode 100644
index 0000000..4c08041
--- /dev/null
+++ b/cc/delegated_frame_data.cc
@@ -0,0 +1,13 @@
+// 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 "cc/delegated_frame_data.h"
+
+namespace cc {
+
+DelegatedFrameData::DelegatedFrameData() {}
+
+DelegatedFrameData::~DelegatedFrameData() {}
+
+}  // namespace cc
diff --git a/cc/delegated_frame_data.h b/cc/delegated_frame_data.h
new file mode 100644
index 0000000..91e0193
--- /dev/null
+++ b/cc/delegated_frame_data.h
@@ -0,0 +1,28 @@
+// 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.
+
+#ifndef CC_DELEGATED_FRAME_DATA_H_
+#define CC_DELEGATED_FRAME_DATA_H_
+
+#include "cc/cc_export.h"
+#include "cc/render_pass.h"
+#include "cc/scoped_ptr_vector.h"
+#include "cc/transferable_resource.h"
+#include "ui/gfx/size.h"
+
+namespace cc {
+
+class CC_EXPORT DelegatedFrameData {
+ public:
+  DelegatedFrameData();
+  ~DelegatedFrameData();
+
+  gfx::Size size;
+  TransferableResourceList resource_list;
+  ScopedPtrVector<RenderPass> render_pass_list;
+};
+
+}  // namespace cc
+
+#endif  // CC_DELEGATED_FRAME_DATA_H_
diff --git a/cc/gl_frame_data.cc b/cc/gl_frame_data.cc
new file mode 100644
index 0000000..9895c79
--- /dev/null
+++ b/cc/gl_frame_data.cc
@@ -0,0 +1,15 @@
+// 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 "cc/gl_frame_data.h"
+
+namespace cc {
+
+GLFrameData::GLFrameData()
+    : sync_point(0) {
+}
+
+GLFrameData::~GLFrameData() {}
+
+}  // namespace cc
diff --git a/cc/gl_frame_data.h b/cc/gl_frame_data.h
new file mode 100644
index 0000000..987f5af
--- /dev/null
+++ b/cc/gl_frame_data.h
@@ -0,0 +1,27 @@
+// 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.
+
+#ifndef CC_GL_FRAME_DATA_H_
+#define CC_GL_FRAME_DATA_H_
+
+#include <string>
+
+#include "base/basictypes.h"
+#include "cc/cc_export.h"
+#include "cc/transferable_resource.h"
+
+namespace cc {
+
+class CC_EXPORT GLFrameData {
+ public:
+  GLFrameData();
+  ~GLFrameData();
+
+  Mailbox mailbox;
+  uint32 sync_point;
+};
+
+}  // namespace cc
+
+#endif  // CC_GL_FRAME_DATA_H_
diff --git a/cc/gl_renderer.cc b/cc/gl_renderer.cc
index e5178ea..bb4ec4d 100644
--- a/cc/gl_renderer.cc
+++ b/cc/gl_renderer.cc
@@ -9,8 +9,11 @@
 #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"
@@ -58,20 +61,21 @@ bool needsIOSurfaceReadbackWorkaround()
 
 } // 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)
@@ -1167,6 +1171,14 @@ void GLRenderer::finishDrawingFrame(DrawingFrame& frame)
 
     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()
diff --git a/cc/gl_renderer.h b/cc/gl_renderer.h
index 494cef2..1fbe28d 100644
--- a/cc/gl_renderer.h
+++ b/cc/gl_renderer.h
@@ -11,6 +11,7 @@
 #include "cc/direct_renderer.h"
 #include "cc/gl_renderer_draw_cache.h"
 #include "cc/io_surface_draw_quad.h"
+#include "cc/output_surface.h"
 #include "cc/render_pass_draw_quad.h"
 #include "cc/renderer.h"
 #include "cc/solid_color_draw_quad.h"
@@ -20,10 +21,6 @@
 #include "third_party/WebKit/Source/Platform/chromium/public/WebGraphicsMemoryAllocation.h"
 #include "ui/gfx/quad_f.h"
 
-namespace WebKit {
-class WebGraphicsContext3D;
-}
-
 namespace cc {
 
 class ScopedResource;
@@ -38,7 +35,7 @@ class CC_EXPORT GLRenderer : public DirectRenderer,
                              public NON_EXPORTED_BASE(WebKit::WebGraphicsContext3D::WebGraphicsMemoryAllocationChangedCallbackCHROMIUM),
                              public NON_EXPORTED_BASE(WebKit::WebGraphicsContext3D::WebGraphicsContextLostCallback) {
 public:
-    static scoped_ptr<GLRenderer> create(RendererClient*, ResourceProvider*);
+    static scoped_ptr<GLRenderer> create(RendererClient*, OutputSurface*, ResourceProvider*);
 
     virtual ~GLRenderer();
 
@@ -64,7 +61,7 @@ public:
     virtual void sendManagedMemoryStats(size_t bytesVisible, size_t bytesVisibleAndNearby, size_t bytesAllocated) OVERRIDE;
 
 protected:
-    GLRenderer(RendererClient*, ResourceProvider*);
+    GLRenderer(RendererClient*, OutputSurface*, ResourceProvider*);
 
     static void debugGLCall(WebKit::WebGraphicsContext3D*, const char* command, const char* file, int line);
 
@@ -218,6 +215,7 @@ private:
 
     scoped_ptr<SolidColorProgram> m_solidColorProgram;
 
+    OutputSurface* m_outputSurface;
     WebKit::WebGraphicsContext3D* m_context;
 
     gfx::Rect m_swapBufferRect;
diff --git a/cc/gl_renderer_pixeltest.cc b/cc/gl_renderer_pixeltest.cc
index d70b06d..b444ee0 100644
--- a/cc/gl_renderer_pixeltest.cc
+++ b/cc/gl_renderer_pixeltest.cc
@@ -6,6 +6,7 @@
 
 #include "base/file_util.h"
 #include "base/path_service.h"
+#include "cc/compositor_frame_metadata.h"
 #include "cc/draw_quad.h"
 #include "cc/prioritized_resource_manager.h"
 #include "cc/resource_provider.h"
@@ -42,6 +43,8 @@ class FakeRendererClient : public RendererClient {
       const ManagedMemoryPolicy&) OVERRIDE {}
   virtual bool hasImplThread() const OVERRIDE { return false; }
   virtual bool shouldClearRootRenderPass() const { return true; }
+  virtual CompositorFrameMetadata makeCompositorFrameMetadata() const
+      OVERRIDE { return CompositorFrameMetadata(); }
 };
 
 class GLRendererPixelTest : public testing::Test {
@@ -52,7 +55,9 @@ class GLRendererPixelTest : public testing::Test {
     gfx::InitializeGLBindings(gfx::kGLImplementationOSMesaGL);
     output_surface_ = PixelTestOutputSurface::create();
     resource_provider_ = ResourceProvider::create(output_surface_.get());
-    renderer_ = GLRenderer::create(&fake_client_, resource_provider_.get());
+    renderer_ = GLRenderer::create(&fake_client_,
+                                   output_surface_.get(),
+                                   resource_provider_.get());
   }
 
   bool PixelsMatchReference(FilePath ref_file, gfx::Rect viewport_rect) {
diff --git a/cc/gl_renderer_unittest.cc b/cc/gl_renderer_unittest.cc
index 560bd2d..b4741cda 100644
--- a/cc/gl_renderer_unittest.cc
+++ b/cc/gl_renderer_unittest.cc
@@ -4,6 +4,7 @@
 
 #include "cc/gl_renderer.h"
 
+#include "cc/compositor_frame_metadata.h"
 #include "cc/draw_quad.h"
 #include "cc/prioritized_resource_manager.h"
 #include "cc/resource_provider.h"
@@ -85,6 +86,8 @@ public:
     virtual void enforceManagedMemoryPolicy(const ManagedMemoryPolicy& policy) OVERRIDE { if (m_lastCallWasSetVisibility) *m_lastCallWasSetVisibility = false; }
     virtual bool hasImplThread() const OVERRIDE { return false; }
     virtual bool shouldClearRootRenderPass() const OVERRIDE { return true; }
+    virtual CompositorFrameMetadata makeCompositorFrameMetadata() const
+        OVERRIDE { return CompositorFrameMetadata(); }
 
     // Methods added for test.
     int setFullRootLayerDamageCount() const { return m_setFullRootLayerDamageCount; }
@@ -109,7 +112,7 @@ private:
 
 class FakeRendererGL : public GLRenderer {
 public:
-    FakeRendererGL(RendererClient* client, ResourceProvider* resourceProvider) : GLRenderer(client, resourceProvider) { }
+    FakeRendererGL(RendererClient* client, OutputSurface* outputSurface, ResourceProvider* resourceProvider) : GLRenderer(client, outputSurface, resourceProvider) { }
 
     // GLRenderer methods.
 
@@ -126,9 +129,9 @@ protected:
     GLRendererTest()
         : m_suggestHaveBackbufferYes(1, true)
         , m_suggestHaveBackbufferNo(1, false)
-        , m_context(FakeOutputSurface::Create3d(scoped_ptr<WebKit::WebGraphicsContext3D>(new FrameCountingMemoryAllocationSettingContext())))
-        , m_resourceProvider(ResourceProvider::create(m_context.get()))
-        , m_renderer(&m_mockClient, m_resourceProvider.get())
+        , m_outputSurface(FakeOutputSurface::Create3d(scoped_ptr<WebKit::WebGraphicsContext3D>(new FrameCountingMemoryAllocationSettingContext())))
+        , m_resourceProvider(ResourceProvider::create(m_outputSurface.get()))
+        , m_renderer(&m_mockClient, m_outputSurface.get(), m_resourceProvider.get())
     {
     }
 
@@ -142,12 +145,12 @@ protected:
         m_renderer.swapBuffers();
     }
 
-    FrameCountingMemoryAllocationSettingContext* context() { return static_cast<FrameCountingMemoryAllocationSettingContext*>(m_context->Context3D()); }
+    FrameCountingMemoryAllocationSettingContext* context() { return static_cast<FrameCountingMemoryAllocationSettingContext*>(m_outputSurface->Context3D()); }
 
     WebGraphicsMemoryAllocation m_suggestHaveBackbufferYes;
     WebGraphicsMemoryAllocation m_suggestHaveBackbufferNo;
 
-    scoped_ptr<OutputSurface> m_context;
+    scoped_ptr<OutputSurface> m_outputSurface;
     FakeRendererClient m_mockClient;
     scoped_ptr<ResourceProvider> m_resourceProvider;
     FakeRendererGL m_renderer;
@@ -308,9 +311,9 @@ public:
 TEST(GLRendererTest2, initializationDoesNotMakeSynchronousCalls)
 {
     FakeRendererClient mockClient;
-    scoped_ptr<OutputSurface> context(FakeOutputSurface::Create3d(scoped_ptr<WebKit::WebGraphicsContext3D>(new ForbidSynchronousCallContext)));
-    scoped_ptr<ResourceProvider> resourceProvider(ResourceProvider::create(context.get()));
-    FakeRendererGL renderer(&mockClient, resourceProvider.get());
+    scoped_ptr<OutputSurface> outputSurface(FakeOutputSurface::Create3d(scoped_ptr<WebKit::WebGraphicsContext3D>(new ForbidSynchronousCallContext)));
+    scoped_ptr<ResourceProvider> resourceProvider(ResourceProvider::create(outputSurface.get()));
+    FakeRendererGL renderer(&mockClient, outputSurface.get(), resourceProvider.get());
 
     EXPECT_TRUE(renderer.initialize());
 }
@@ -351,9 +354,9 @@ private:
 TEST(GLRendererTest2, initializationWithQuicklyLostContextDoesNotAssert)
 {
     FakeRendererClient mockClient;
-    scoped_ptr<OutputSurface> context(FakeOutputSurface::Create3d(scoped_ptr<WebKit::WebGraphicsContext3D>(new LoseContextOnFirstGetContext)));
-    scoped_ptr<ResourceProvider> resourceProvider(ResourceProvider::create(context.get()));
-    FakeRendererGL renderer(&mockClient, resourceProvider.get());
+    scoped_ptr<OutputSurface> outputSurface(FakeOutputSurface::Create3d(scoped_ptr<WebKit::WebGraphicsContext3D>(new LoseContextOnFirstGetContext)));
+    scoped_ptr<ResourceProvider> resourceProvider(ResourceProvider::create(outputSurface.get()));
+    FakeRendererGL renderer(&mockClient, outputSurface.get(), resourceProvider.get());
 
     renderer.initialize();
 }
@@ -375,7 +378,7 @@ TEST(GLRendererTest2, initializationWithoutGpuMemoryManagerExtensionSupportShoul
     FakeRendererClient mockClient;
     scoped_ptr<OutputSurface> outputSurface(FakeOutputSurface::Create3d(scoped_ptr<WebKit::WebGraphicsContext3D>(new ContextThatDoesNotSupportMemoryManagmentExtensions)));
     scoped_ptr<ResourceProvider> resourceProvider(ResourceProvider::create(outputSurface.get()));
-    FakeRendererGL renderer(&mockClient, resourceProvider.get());
+    FakeRendererGL renderer(&mockClient, outputSurface.get(), resourceProvider.get());
 
     renderer.initialize();
 
@@ -403,7 +406,7 @@ TEST(GLRendererTest2, opaqueBackground)
     scoped_ptr<OutputSurface> outputSurface(FakeOutputSurface::Create3d(scoped_ptr<WebKit::WebGraphicsContext3D>(new ClearCountingContext)));
     ClearCountingContext* context = static_cast<ClearCountingContext*>(outputSurface->Context3D());
     scoped_ptr<ResourceProvider> resourceProvider(ResourceProvider::create(outputSurface.get()));
-    FakeRendererGL renderer(&mockClient, resourceProvider.get());
+    FakeRendererGL renderer(&mockClient, outputSurface.get(), resourceProvider.get());
 
     mockClient.rootRenderPass()->has_transparent_background = false;
 
@@ -426,7 +429,7 @@ TEST(GLRendererTest2, transparentBackground)
     scoped_ptr<OutputSurface> outputSurface(FakeOutputSurface::Create3d(scoped_ptr<WebKit::WebGraphicsContext3D>(new ClearCountingContext)));
     ClearCountingContext* context = static_cast<ClearCountingContext*>(outputSurface->Context3D());
     scoped_ptr<ResourceProvider> resourceProvider(ResourceProvider::create(outputSurface.get()));
-    FakeRendererGL renderer(&mockClient, resourceProvider.get());
+    FakeRendererGL renderer(&mockClient, outputSurface.get(), resourceProvider.get());
 
     mockClient.rootRenderPass()->has_transparent_background = true;
 
@@ -477,7 +480,7 @@ TEST(GLRendererTest2, visibilityChangeIsLastCall)
     scoped_ptr<OutputSurface> outputSurface(FakeOutputSurface::Create3d(scoped_ptr<WebKit::WebGraphicsContext3D>(new VisibilityChangeIsLastCallTrackingContext)));
     VisibilityChangeIsLastCallTrackingContext* context = static_cast<VisibilityChangeIsLastCallTrackingContext*>(outputSurface->Context3D());
     scoped_ptr<ResourceProvider> resourceProvider(ResourceProvider::create(outputSurface.get()));
-    FakeRendererGL renderer(&mockClient, resourceProvider.get());
+    FakeRendererGL renderer(&mockClient, outputSurface.get(), resourceProvider.get());
 
     EXPECT_TRUE(renderer.initialize());
 
@@ -529,7 +532,7 @@ TEST(GLRendererTest2, activeTextureState)
     scoped_ptr<OutputSurface> outputSurface(FakeOutputSurface::Create3d(scoped_ptr<WebKit::WebGraphicsContext3D>(new TextureStateTrackingContext)));
     TextureStateTrackingContext* context = static_cast<TextureStateTrackingContext*>(outputSurface->Context3D());
     scoped_ptr<ResourceProvider> resourceProvider(ResourceProvider::create(outputSurface.get()));
-    FakeRendererGL renderer(&fakeClient, resourceProvider.get());
+    FakeRendererGL renderer(&fakeClient, outputSurface.get(), resourceProvider.get());
 
     // During initialization we are allowed to set any texture parameters.
     EXPECT_CALL(*context, texParameteri(_, _, _)).Times(AnyNumber());
@@ -597,9 +600,8 @@ TEST(GLRendererTest2, shouldClearRootRenderPass)
     NoClearRootRenderPassFakeClient mockClient;
     scoped_ptr<OutputSurface> outputSurface(FakeOutputSurface::Create3d(scoped_ptr<WebKit::WebGraphicsContext3D>(new NoClearRootRenderPassMockContext)));
     NoClearRootRenderPassMockContext* mockContext = static_cast<NoClearRootRenderPassMockContext*>(outputSurface->Context3D());
-
     scoped_ptr<ResourceProvider> resourceProvider(ResourceProvider::create(outputSurface.get()));
-    FakeRendererGL renderer(&mockClient, resourceProvider.get());
+    FakeRendererGL renderer(&mockClient, outputSurface.get(), resourceProvider.get());
     EXPECT_TRUE(renderer.initialize());
 
     gfx::Rect viewportRect(mockClient.deviceViewportSize());
diff --git a/cc/layer_tree_host_impl.cc b/cc/layer_tree_host_impl.cc
index e7874b6..740c361 100644
--- a/cc/layer_tree_host_impl.cc
+++ b/cc/layer_tree_host_impl.cc
@@ -10,6 +10,7 @@
 #include "base/debug/trace_event.h"
 #include "base/json/json_writer.h"
 #include "cc/append_quads_data.h"
+#include "cc/compositor_frame_metadata.h"
 #include "cc/damage_tracker.h"
 #include "cc/debug_rect_history.h"
 #include "cc/delay_based_time_source.h"
@@ -881,6 +882,26 @@ void LayerTreeHostImpl::OnCanDrawStateChangedForTree(LayerTreeImpl*)
     m_client->onCanDrawStateChanged(canDraw());
 }
 
+CompositorFrameMetadata LayerTreeHostImpl::makeCompositorFrameMetadata() const
+{
+    if (!rootScrollLayer())
+        return CompositorFrameMetadata();
+
+    CompositorFrameMetadata metadata;
+    metadata.root_scroll_offset = rootScrollLayer()->scrollOffset() + rootScrollLayer()->scrollDelta();
+    metadata.page_scale_factor = m_pinchZoomViewport.totalPageScaleFactor();
+    metadata.viewport_size = m_pinchZoomViewport.bounds().size();
+    metadata.root_layer_size = rootScrollLayer()->bounds();
+    metadata.min_page_scale_factor = m_pinchZoomViewport.minPageScaleFactor();
+    metadata.max_page_scale_factor = m_pinchZoomViewport.maxPageScaleFactor();
+    if (!m_settings.pageScalePinchZoomEnabled) {
+        metadata.root_scroll_offset.Scale(1 / m_pinchZoomViewport.pageScaleFactor());
+        metadata.root_layer_size.Scale(1 / m_pinchZoomViewport.pageScaleFactor());
+    }
+
+    return metadata;
+}
+
 void LayerTreeHostImpl::drawLayers(FrameData& frame)
 {
     TRACE_EVENT0("cc", "LayerTreeHostImpl::drawLayers");
@@ -1064,7 +1085,7 @@ bool LayerTreeHostImpl::initializeRenderer(scoped_ptr<OutputSurface> outputSurfa
     if (outputSurface->Capabilities().has_parent_compositor)
         m_renderer = DelegatingRenderer::Create(this, resourceProvider.get());
     else if (outputSurface->Context3D())
-        m_renderer = GLRenderer::create(this, resourceProvider.get());
+        m_renderer = GLRenderer::create(this, outputSurface.get(), resourceProvider.get());
     else if (outputSurface->SoftwareDevice())
         m_renderer = SoftwareRenderer::create(this, resourceProvider.get(), outputSurface->SoftwareDevice());
     if (!m_renderer)
diff --git a/cc/layer_tree_host_impl.h b/cc/layer_tree_host_impl.h
index 79c26c02..5337f19 100644
--- a/cc/layer_tree_host_impl.h
+++ b/cc/layer_tree_host_impl.h
@@ -22,6 +22,7 @@
 namespace cc {
 
 class CompletionEvent;
+class CompositorFrameMetadata;
 class DebugRectHistory;
 class FrameRateCounter;
 class LayerImpl;
@@ -171,6 +172,7 @@ public:
     virtual void enforceManagedMemoryPolicy(const ManagedMemoryPolicy& policy) OVERRIDE;
     virtual bool hasImplThread() const OVERRIDE;
     virtual bool shouldClearRootRenderPass() const OVERRIDE;
+    virtual CompositorFrameMetadata makeCompositorFrameMetadata() const OVERRIDE;
 
     // TileManagerClient implementation.
     virtual void ScheduleManageTiles() OVERRIDE;
diff --git a/cc/layer_tree_host_impl_unittest.cc b/cc/layer_tree_host_impl_unittest.cc
index d439760..3a60455 100644
--- a/cc/layer_tree_host_impl_unittest.cc
+++ b/cc/layer_tree_host_impl_unittest.cc
@@ -9,6 +9,7 @@
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/hash_tables.h"
+#include "cc/compositor_frame_metadata.h"
 #include "cc/delegated_renderer_layer_impl.h"
 #include "cc/gl_renderer.h"
 #include "cc/heads_up_display_layer_impl.h"
@@ -4100,9 +4101,9 @@ struct RenderPassRemovalTestData : public LayerTreeHostImpl::FrameData {
 
 class TestRenderer : public GLRenderer, public RendererClient {
 public:
-    static scoped_ptr<TestRenderer> create(ResourceProvider* resourceProvider, Proxy* proxy)
+    static scoped_ptr<TestRenderer> create(ResourceProvider* resourceProvider, OutputSurface* outputSurface, Proxy* proxy)
     {
-        scoped_ptr<TestRenderer> renderer(new TestRenderer(resourceProvider, proxy));
+        scoped_ptr<TestRenderer> renderer(new TestRenderer(resourceProvider, outputSurface, proxy));
         if (!renderer->initialize())
             return scoped_ptr<TestRenderer>();
 
@@ -4124,9 +4125,11 @@ public:
     virtual void enforceManagedMemoryPolicy(const ManagedMemoryPolicy& policy) OVERRIDE { }
     virtual bool hasImplThread() const OVERRIDE { return false; }
     virtual bool shouldClearRootRenderPass() const OVERRIDE { return true; }
+    virtual CompositorFrameMetadata makeCompositorFrameMetadata() const
+        OVERRIDE { return CompositorFrameMetadata(); }
 
 protected:
-    TestRenderer(ResourceProvider* resourceProvider, Proxy* proxy) : GLRenderer(this, resourceProvider) { }
+    TestRenderer(ResourceProvider* resourceProvider, OutputSurface* outputSurface, Proxy* proxy) : GLRenderer(this, outputSurface, resourceProvider) { }
 
 private:
     LayerTreeSettings m_settings;
@@ -4417,7 +4420,7 @@ TEST_P(LayerTreeHostImplTest, testRemoveRenderPasses)
     ASSERT_TRUE(outputSurface->Context3D());
     scoped_ptr<ResourceProvider> resourceProvider(ResourceProvider::create(outputSurface.get()));
 
-    scoped_ptr<TestRenderer> renderer(TestRenderer::create(resourceProvider.get(), &m_proxy));
+    scoped_ptr<TestRenderer> renderer(TestRenderer::create(resourceProvider.get(), outputSurface.get(), &m_proxy));
 
     int testCaseIndex = 0;
     while (removeRenderPassesCases[testCaseIndex].name) {
diff --git a/cc/layer_tree_settings.cc b/cc/layer_tree_settings.cc
index 4ef2b7b..4221167 100644
--- a/cc/layer_tree_settings.cc
+++ b/cc/layer_tree_settings.cc
@@ -15,6 +15,7 @@ namespace cc {
 
 LayerTreeSettings::LayerTreeSettings()
     : acceleratePainting(false)
+    , compositorFrameMessage(false)
     , implSidePainting(false)
     , renderVSyncEnabled(true)
     , perTilePaintingEnabled(false)
@@ -33,6 +34,7 @@ LayerTreeSettings::LayerTreeSettings()
     , minimumOcclusionTrackingSize(gfx::Size(160, 160))
 {
     // TODO(danakj): Move this to chromium when we don't go through the WebKit API anymore.
+    compositorFrameMessage = CommandLine::ForCurrentProcess()->HasSwitch(cc::switches::kEnableCompositorFrameMessage);
     implSidePainting = CommandLine::ForCurrentProcess()->HasSwitch(cc::switches::kEnableImplSidePainting);
     partialSwapEnabled = CommandLine::ForCurrentProcess()->HasSwitch(switches::kEnablePartialSwap);
     backgroundColorInsteadOfCheckerboard = CommandLine::ForCurrentProcess()->HasSwitch(switches::kBackgroundColorInsteadOfCheckerboard);
diff --git a/cc/layer_tree_settings.h b/cc/layer_tree_settings.h
index e5ca724..847795f 100644
--- a/cc/layer_tree_settings.h
+++ b/cc/layer_tree_settings.h
@@ -18,6 +18,7 @@ class CC_EXPORT LayerTreeSettings {
   ~LayerTreeSettings();
 
   bool acceleratePainting;
+  bool compositorFrameMessage;
   bool implSidePainting;
   bool renderVSyncEnabled;
   bool perTilePaintingEnabled;
diff --git a/cc/renderer.h b/cc/renderer.h
index 2adf7c0..36d6791e 100644
--- a/cc/renderer.h
+++ b/cc/renderer.h
@@ -14,6 +14,7 @@
 namespace cc {
 
 class CompositorFrameAck;
+class CompositorFrameMetadata;
 class ScopedResource;
 
 class CC_EXPORT RendererClient {
@@ -27,6 +28,7 @@ public:
     virtual void enforceManagedMemoryPolicy(const ManagedMemoryPolicy& policy) = 0;
     virtual bool hasImplThread() const = 0;
     virtual bool shouldClearRootRenderPass() const = 0;
+    virtual CompositorFrameMetadata makeCompositorFrameMetadata() const = 0;
 protected:
     virtual ~RendererClient() { }
 };
diff --git a/cc/software_renderer_unittest.cc b/cc/software_renderer_unittest.cc
index f7dc195..21e5d6f 100644
--- a/cc/software_renderer_unittest.cc
+++ b/cc/software_renderer_unittest.cc
@@ -4,6 +4,7 @@
 
 #include "cc/software_renderer.h"
 
+#include "cc/compositor_frame_metadata.h"
 #include "cc/quad_sink.h"
 #include "cc/render_pass.h"
 #include "cc/render_pass_draw_quad.h"
@@ -53,6 +54,8 @@ public:
     virtual void enforceManagedMemoryPolicy(const ManagedMemoryPolicy& policy) OVERRIDE { };
     virtual bool hasImplThread() const OVERRIDE { return false; }
     virtual bool shouldClearRootRenderPass() const OVERRIDE { return m_shouldClearRootRenderPass; }
+    virtual CompositorFrameMetadata makeCompositorFrameMetadata() const
+        OVERRIDE { return CompositorFrameMetadata(); }
 
 protected:
     scoped_ptr<FakeOutputSurface> m_outputSurface;
diff --git a/cc/switches.cc b/cc/switches.cc
index ee119bc..2cbb459 100644
--- a/cc/switches.cc
+++ b/cc/switches.cc
@@ -14,6 +14,9 @@ const char kBackgroundColorInsteadOfCheckerboard[] =
 
 const char kDisableThreadedAnimation[]      = "disable-threaded-animation";
 
+// Send a message for every frame from the impl thread to the parent compositor.
+const char kEnableCompositorFrameMessage[] = "enable-compositor-frame-message";
+
 // Paint content on the compositor thread instead of the main thread.
 const char kEnableImplSidePainting[] = "enable-impl-side-painting";
 
diff --git a/cc/switches.h b/cc/switches.h
index 164b2de..e3797bb 100644
--- a/cc/switches.h
+++ b/cc/switches.h
@@ -17,6 +17,7 @@ namespace switches {
 
 CC_EXPORT extern const char kBackgroundColorInsteadOfCheckerboard[];
 CC_EXPORT extern const char kDisableThreadedAnimation[];
+CC_EXPORT extern const char kEnableCompositorFrameMessage[];
 CC_EXPORT extern const char kEnableImplSidePainting[];
 CC_EXPORT extern const char kEnablePartialSwap[];
 CC_EXPORT extern const char kEnablePerTilePainting[];
diff --git a/cc/transferable_resource.cc b/cc/transferable_resource.cc
index 39eba20..9d5eeb4 100644
--- a/cc/transferable_resource.cc
+++ b/cc/transferable_resource.cc
@@ -19,7 +19,7 @@ bool Mailbox::isZero() const {
   return true;
 }
 
-void Mailbox::setName(const GLbyte* n) {
+void Mailbox::setName(const int8* n) {
   DCHECK(isZero() || !memcmp(name, n, sizeof(name)));
   memcpy(name, n, sizeof(name));
 }
diff --git a/cc/transferable_resource.h b/cc/transferable_resource.h
index f4e434f..1ab5611 100644
--- a/cc/transferable_resource.h
+++ b/cc/transferable_resource.h
@@ -7,17 +7,17 @@
 
 #include <vector>
 
+#include "base/basictypes.h"
 #include "cc/cc_export.h"
 #include "ui/gfx/size.h"
-#include "third_party/khronos/GLES2/gl2.h"
 
 namespace cc {
 
 struct CC_EXPORT Mailbox {
   Mailbox();
   bool isZero() const;
-  void setName(const GLbyte* name);
-  GLbyte name[64];
+  void setName(const int8* name);
+  int8 name[64];
 };
 
 struct CC_EXPORT TransferableResource {
@@ -25,8 +25,8 @@ struct CC_EXPORT TransferableResource {
   ~TransferableResource();
 
   unsigned id;
-  GLenum format;
-  GLenum filter;
+  uint32 format;
+  uint32 filter;
   gfx::Size size;
   Mailbox mailbox;
 };
diff --git a/content/browser/android/content_startup_flags.cc b/content/browser/android/content_startup_flags.cc
index 16beb8f..c22bed5 100644
--- a/content/browser/android/content_startup_flags.cc
+++ b/content/browser/android/content_startup_flags.cc
@@ -7,6 +7,7 @@
 #include "base/string_number_conversions.h"
 #include "base/command_line.h"
 #include "base/logging.h"
+#include "cc/switches.h"
 #include "content/public/browser/render_process_host.h"
 #include "content/public/common/content_constants.h"
 #include "content/public/common/content_switches.h"
@@ -60,6 +61,9 @@ void SetContentCommandLineFlags(int max_render_process_count) {
   // Always use fixed layout and viewport tag.
   parsed_command_line->AppendSwitch(switches::kEnableFixedLayout);
   parsed_command_line->AppendSwitch(switches::kEnableViewport);
+
+  parsed_command_line->AppendSwitch(
+      cc::switches::kEnableCompositorFrameMessage);
 }
 
 }  // namespace content
diff --git a/content/browser/renderer_host/render_process_host_impl.cc b/content/browser/renderer_host/render_process_host_impl.cc
index bb7da0c..1605a62c 100644
--- a/content/browser/renderer_host/render_process_host_impl.cc
+++ b/content/browser/renderer_host/render_process_host_impl.cc
@@ -834,6 +834,7 @@ void RenderProcessHostImpl::PropagateBrowserCommandLineToRenderer(
     switches::kWebCoreLogChannels,
     switches::kWebIntentsInvocationEnabled,
     cc::switches::kBackgroundColorInsteadOfCheckerboard,
+    cc::switches::kEnableCompositorFrameMessage,
     cc::switches::kEnableImplSidePainting,
     cc::switches::kEnablePartialSwap,
     cc::switches::kNumRasterThreads,
diff --git a/content/browser/renderer_host/render_widget_host_impl.cc b/content/browser/renderer_host/render_widget_host_impl.cc
index 31f1338..de4ab7f 100644
--- a/content/browser/renderer_host/render_widget_host_impl.cc
+++ b/content/browser/renderer_host/render_widget_host_impl.cc
@@ -17,6 +17,7 @@
 #include "base/metrics/histogram.h"
 #include "base/string_number_conversions.h"
 #include "base/utf_string_conversions.h"
+#include "cc/compositor_frame.h"
 #include "content/browser/gpu/gpu_process_host.h"
 #include "content/browser/gpu/gpu_process_host_ui_shim.h"
 #include "content/browser/gpu/gpu_surface_tracker.h"
@@ -54,6 +55,7 @@
 #include "ui/base/keycodes/keyboard_codes.h"
 #include "ui/gfx/size_conversions.h"
 #include "ui/gfx/skbitmap_operations.h"
+#include "ui/gfx/vector2d_conversions.h"
 #include "webkit/glue/webcursor.h"
 #include "webkit/glue/webpreferences.h"
 #include "webkit/plugins/npapi/webplugin.h"
@@ -331,6 +333,8 @@ bool RenderWidgetHostImpl::OnMessageReceived(const IPC::Message &msg) {
     IPC_MESSAGE_HANDLER(ViewHostMsg_PaintAtSize_ACK, OnMsgPaintAtSizeAck)
     IPC_MESSAGE_HANDLER(ViewHostMsg_CompositorSurfaceBuffersSwapped,
                         OnCompositorSurfaceBuffersSwapped)
+    IPC_MESSAGE_HANDLER(ViewHostMsg_SwapCompositorFrame,
+                        OnMsgSwapCompositorFrame)
     IPC_MESSAGE_HANDLER(ViewHostMsg_UpdateRect, OnMsgUpdateRect)
     IPC_MESSAGE_HANDLER(ViewHostMsg_UpdateIsDelayed, OnMsgUpdateIsDelayed)
     IPC_MESSAGE_HANDLER(ViewHostMsg_HandleInputEvent_ACK, OnMsgInputEventAck)
@@ -1511,6 +1515,25 @@ void RenderWidgetHostImpl::OnCompositorSurfaceBuffersSwapped(
                                           gpu_process_host_id);
 }
 
+void RenderWidgetHostImpl::OnMsgSwapCompositorFrame(
+    const cc::CompositorFrame& frame) {
+#if defined(OS_ANDROID)
+  gfx::Vector2dF scroll_offset = ScaleVector2d(
+      frame.metadata.root_scroll_offset, frame.metadata.page_scale_factor);
+  gfx::SizeF content_size = ScaleSize(
+      frame.metadata.root_layer_size, frame.metadata.page_scale_factor);
+
+  if (view_) {
+    view_->UpdateFrameInfo(
+        gfx::ToRoundedVector2d(scroll_offset),
+        frame.metadata.page_scale_factor,
+        frame.metadata.min_page_scale_factor,
+        frame.metadata.max_page_scale_factor,
+        gfx::ToCeiledSize(content_size));
+  }
+#endif
+}
+
 void RenderWidgetHostImpl::OnMsgUpdateRect(
     const ViewHostMsg_UpdateRect_Params& params) {
   TRACE_EVENT0("renderer_host", "RenderWidgetHostImpl::OnMsgUpdateRect");
diff --git a/content/browser/renderer_host/render_widget_host_impl.h b/content/browser/renderer_host/render_widget_host_impl.h
index 8ae0bf3..4224e5a 100644
--- a/content/browser/renderer_host/render_widget_host_impl.h
+++ b/content/browser/renderer_host/render_widget_host_impl.h
@@ -39,6 +39,10 @@ namespace base {
 class TimeTicks;
 }
 
+namespace cc {
+class CompositorFrame;
+}
+
 namespace ui {
 class KeyEvent;
 class Range;
@@ -559,6 +563,7 @@ class CONTENT_EXPORT RenderWidgetHostImpl : virtual public RenderWidgetHost,
                                          int32 route_id,
                                          const gfx::Size& size,
                                          int32 gpu_process_host_id);
+  void OnMsgSwapCompositorFrame(const cc::CompositorFrame& frame);
   void OnMsgUpdateRect(const ViewHostMsg_UpdateRect_Params& params);
   void OnMsgUpdateIsDelayed();
   void OnMsgInputEventAck(WebKit::WebInputEvent::Type event_type,
diff --git a/content/common/cc_messages.cc b/content/common/cc_messages.cc
index 04d3af9..f141d4d 100644
--- a/content/common/cc_messages.cc
+++ b/content/common/cc_messages.cc
@@ -569,7 +569,68 @@ void ParamTraits<cc::Mailbox>::Log(const param_type& p, std::string* l) {
     *l += base::StringPrintf("%02x", p.name[i]);
 }
 
-void ParamTraits<cc::CompositorFrame>::Write(Message* m, const param_type& p) {
+namespace {
+  enum CompositorFrameType {
+    DELEGATED_FRAME,
+    GL_FRAME,
+  };
+}
+
+void ParamTraits<cc::CompositorFrame>::Write(Message* m,
+                                             const param_type& p) {
+  WriteParam(m, p.metadata);
+  if (p.delegated_frame_data) {
+    DCHECK(!p.gl_frame_data);
+    WriteParam(m, static_cast<int>(DELEGATED_FRAME));
+    WriteParam(m, *p.delegated_frame_data);
+  } else {
+    DCHECK(p.gl_frame_data);
+    WriteParam(m, static_cast<int>(GL_FRAME));
+    WriteParam(m, *p.gl_frame_data);
+  }
+}
+
+bool ParamTraits<cc::CompositorFrame>::Read(const Message* m,
+                                            PickleIterator* iter,
+                                            param_type* p) {
+  if (!ReadParam(m, iter, &p->metadata))
+    return false;
+
+  int compositor_frame_type;
+  if (!ReadParam(m, iter, &compositor_frame_type))
+    return false;
+
+  switch (compositor_frame_type) {
+    case DELEGATED_FRAME:
+      p->delegated_frame_data.reset(new cc::DelegatedFrameData());
+      if (!ReadParam(m, iter, p->delegated_frame_data.get()))
+        return false;
+      break;
+    case GL_FRAME:
+      p->gl_frame_data.reset(new cc::GLFrameData());
+      if (!ReadParam(m, iter, p->gl_frame_data.get()))
+        return false;
+      break;
+    default:
+      return false;
+  }
+  return true;
+}
+
+void ParamTraits<cc::CompositorFrame>::Log(const param_type& p,
+                                           std::string* l) {
+  l->append("CompositorFrame(");
+  LogParam(p.metadata, l);
+  l->append(", ");
+  if (p.delegated_frame_data)
+    LogParam(*p.delegated_frame_data, l);
+  else if (p.gl_frame_data)
+    LogParam(*p.gl_frame_data, l);
+  l->append(")");
+}
+
+void ParamTraits<cc::DelegatedFrameData>::Write(Message* m,
+                                                const param_type& p) {
   WriteParam(m, p.size);
   WriteParam(m, p.resource_list);
   WriteParam(m, p.render_pass_list.size());
@@ -577,9 +638,9 @@ void ParamTraits<cc::CompositorFrame>::Write(Message* m, const param_type& p) {
     WriteParam(m, *p.render_pass_list[i]);
 }
 
-bool ParamTraits<cc::CompositorFrame>::Read(const Message* m,
-                                            PickleIterator* iter,
-                                            param_type* p) {
+bool ParamTraits<cc::DelegatedFrameData>::Read(const Message* m,
+                                               PickleIterator* iter,
+                                               param_type* p) {
   const static size_t kMaxRenderPasses = 10000;
 
   size_t num_render_passes;
@@ -597,9 +658,9 @@ bool ParamTraits<cc::CompositorFrame>::Read(const Message* m,
   return true;
 }
 
-void ParamTraits<cc::CompositorFrame>::Log(const param_type& p,
-                                           std::string* l) {
-  l->append("CompositorFrame(");
+void ParamTraits<cc::DelegatedFrameData>::Log(const param_type& p,
+                                              std::string* l) {
+  l->append("DelegatedFrameData(");
   LogParam(p.size, l);
   l->append(", ");
   LogParam(p.resource_list, l);
diff --git a/content/common/cc_messages.h b/content/common/cc_messages.h
index 5730309..dfe9ef6 100644
--- a/content/common/cc_messages.h
+++ b/content/common/cc_messages.h
@@ -5,6 +5,7 @@
 // IPC Messages sent between compositor instances.
 
 #include "cc/checkerboard_draw_quad.h"
+#include "cc/compositor_frame.h"
 #include "cc/compositor_frame_ack.h"
 #include "cc/debug_border_draw_quad.h"
 #include "cc/draw_quad.h"
@@ -89,6 +90,14 @@ struct CONTENT_EXPORT ParamTraits<cc::CompositorFrame> {
   static void Log(const param_type& p, std::string* l);
 };
 
+template<>
+struct CONTENT_EXPORT ParamTraits<cc::DelegatedFrameData> {
+  typedef cc::DelegatedFrameData param_type;
+  static void Write(Message* m, const param_type& p);
+  static bool Read(const Message* m, PickleIterator* iter, param_type* p);
+  static void Log(const param_type& p, std::string* l);
+};
+
 }  // namespace IPC
 
 #endif  // CONTENT_COMMON_CC_MESSAGES_H_
@@ -211,3 +220,18 @@ IPC_STRUCT_TRAITS_END()
 IPC_STRUCT_TRAITS_BEGIN(cc::CompositorFrameAck)
   IPC_STRUCT_TRAITS_MEMBER(resources)
 IPC_STRUCT_TRAITS_END()
+
+IPC_STRUCT_TRAITS_BEGIN(cc::CompositorFrameMetadata)
+  IPC_STRUCT_TRAITS_MEMBER(root_scroll_offset)
+  IPC_STRUCT_TRAITS_MEMBER(page_scale_factor)
+  IPC_STRUCT_TRAITS_MEMBER(viewport_size)
+  IPC_STRUCT_TRAITS_MEMBER(root_layer_size)
+  IPC_STRUCT_TRAITS_MEMBER(min_page_scale_factor)
+  IPC_STRUCT_TRAITS_MEMBER(max_page_scale_factor)
+  IPC_STRUCT_TRAITS_MEMBER(location_bar_offset)
+IPC_STRUCT_TRAITS_END()
+
+IPC_STRUCT_TRAITS_BEGIN(cc::GLFrameData)
+  IPC_STRUCT_TRAITS_MEMBER(mailbox)
+  IPC_STRUCT_TRAITS_MEMBER(sync_point)
+IPC_STRUCT_TRAITS_END()
diff --git a/content/common/cc_messages_unittest.cc b/content/common/cc_messages_unittest.cc
index 924223c..bfcb087 100644
--- a/content/common/cc_messages_unittest.cc
+++ b/content/common/cc_messages_unittest.cc
@@ -11,7 +11,7 @@
 #include "testing/gtest/include/gtest/gtest.h"
 
 using cc::CheckerboardDrawQuad;
-using cc::CompositorFrame;
+using cc::DelegatedFrameData;
 using cc::DebugBorderDrawQuad;
 using cc::DrawQuad;
 using cc::IOSurfaceDrawQuad;
@@ -413,15 +413,16 @@ TEST_F(CCMessagesTest, AllQuads) {
     EXPECT_EQ(same_shared_quad_state_cmp, same_shared_quad_state_in);
   }
 
-  CompositorFrame frame_in;
+  DelegatedFrameData frame_in;
   frame_in.size = arbitrary_size1;
   frame_in.render_pass_list.append(pass_in.Pass());
 
-  IPC::ParamTraits<CompositorFrame>::Write(&msg, frame_in);
+  IPC::ParamTraits<DelegatedFrameData>::Write(&msg, frame_in);
 
-  CompositorFrame frame_out;
+  DelegatedFrameData frame_out;
   PickleIterator iter(msg);
-  EXPECT_TRUE(IPC::ParamTraits<CompositorFrame>::Read(&msg, &iter, &frame_out));
+  EXPECT_TRUE(IPC::ParamTraits<DelegatedFrameData>::Read(&msg,
+      &iter, &frame_out));
 
   EXPECT_EQ(arbitrary_size1, frame_out.size);
 
@@ -478,18 +479,19 @@ TEST_F(CCMessagesTest, Resources) {
   arbitrary_resource2.size = gfx::Size(89123, 23789);
   arbitrary_resource2.mailbox.setName(arbitrary_mailbox2);
 
-  CompositorFrame frame_in;
+  DelegatedFrameData frame_in;
   frame_in.size = arbitrary_size;
 
   frame_in.resource_list.sync_point = arbitrary_uint;
   frame_in.resource_list.resources.push_back(arbitrary_resource1);
   frame_in.resource_list.resources.push_back(arbitrary_resource2);
 
-  IPC::ParamTraits<CompositorFrame>::Write(&msg, frame_in);
+  IPC::ParamTraits<DelegatedFrameData>::Write(&msg, frame_in);
 
-  CompositorFrame frame_out;
+  DelegatedFrameData frame_out;
   PickleIterator iter(msg);
-  EXPECT_TRUE(IPC::ParamTraits<CompositorFrame>::Read(&msg, &iter, &frame_out));
+  EXPECT_TRUE(IPC::ParamTraits<DelegatedFrameData>::Read(&msg,
+      &iter, &frame_out));
 
   EXPECT_EQ(arbitrary_size.ToString(), frame_out.size.ToString());
   EXPECT_EQ(arbitrary_uint, frame_out.resource_list.sync_point);
diff --git a/content/common/view_messages.h b/content/common/view_messages.h
index d2464e9..7e74f33 100644
--- a/content/common/view_messages.h
+++ b/content/common/view_messages.h
@@ -8,6 +8,8 @@
 #include "base/process.h"
 #include "base/shared_memory.h"
 #include "base/string16.h"
+#include "cc/compositor_frame.h"
+#include "cc/compositor_frame_ack.h"
 #include "content/common/content_export.h"
 #include "content/common/content_param_traits.h"
 #include "content/common/edit_command.h"
@@ -2253,6 +2255,11 @@ IPC_MESSAGE_ROUTED5(ViewHostMsg_CompositorSurfaceBuffersSwapped,
                     gfx::Size /* size */,
                     int32 /* gpu_process_host_id */)
 
+IPC_MESSAGE_ROUTED1(ViewHostMsg_SwapCompositorFrame,
+                    cc::CompositorFrame /* frame */)
+IPC_MESSAGE_ROUTED1(ViewHostMsg_SwapCompositorFrameAck,
+                    cc::CompositorFrameAck /* ack */)
+
 // Opens a file asynchronously. The response returns a file descriptor
 // and an error code from base/platform_file.h.
 IPC_MESSAGE_ROUTED3(ViewHostMsg_AsyncOpenFile,
diff --git a/content/renderer/gpu/compositor_output_surface.cc b/content/renderer/gpu/compositor_output_surface.cc
index 21eaf80..5578298 100644
--- a/content/renderer/gpu/compositor_output_surface.cc
+++ b/content/renderer/gpu/compositor_output_surface.cc
@@ -5,13 +5,16 @@
 #include "content/renderer/gpu/compositor_output_surface.h"
 
 #include "base/message_loop_proxy.h"
+#include "cc/compositor_frame.h"
 #include "cc/output_surface_client.h"
 #include "content/common/view_messages.h"
 #include "content/renderer/render_thread_impl.h"
 #include "ipc/ipc_forwarding_message_filter.h"
 #include "ipc/ipc_sync_channel.h"
+#include "ipc/ipc_sync_message_filter.h"
 #include "third_party/WebKit/Source/Platform/chromium/public/WebGraphicsContext3D.h"
 
+using cc::CompositorFrame;
 using cc::SoftwareOutputDevice;
 using WebKit::WebGraphicsContext3D;
 
@@ -88,9 +91,9 @@ cc::SoftwareOutputDevice* CompositorOutputSurface::SoftwareDevice() const {
 }
 
 void CompositorOutputSurface::SendFrameToParentCompositor(
-    const cc::CompositorFrame&) {
+    const cc::CompositorFrame& frame) {
   DCHECK(CalledOnValidThread());
-  NOTREACHED();
+  Send(new ViewHostMsg_SwapCompositorFrame(routing_id_, frame));
 }
 
 void CompositorOutputSurface::OnMessageReceived(const IPC::Message& message) {
@@ -109,4 +112,8 @@ void CompositorOutputSurface::OnUpdateVSyncParameters(
   client_->OnVSyncParametersChanged(timebase, interval);
 }
 
+bool CompositorOutputSurface::Send(IPC::Message* message) {
+  return ChildThread::current()->sync_message_filter()->Send(message);
+}
+
 }  // namespace content
diff --git a/content/renderer/gpu/compositor_output_surface.h b/content/renderer/gpu/compositor_output_surface.h
index d288ad9..b14c4a0 100644
--- a/content/renderer/gpu/compositor_output_surface.h
+++ b/content/renderer/gpu/compositor_output_surface.h
@@ -71,6 +71,7 @@ class CompositorOutputSurface
   void OnMessageReceived(const IPC::Message& message);
   void OnUpdateVSyncParameters(
       base::TimeTicks timebase, base::TimeDelta interval);
+  bool Send(IPC::Message* message);
 
   scoped_refptr<IPC::ForwardingMessageFilter> output_surface_filter_;
   cc::OutputSurfaceClient* client_;
diff --git a/content/renderer/render_view_impl_android.cc b/content/renderer/render_view_impl_android.cc
index 031cdc8..18a42b5 100644
--- a/content/renderer/render_view_impl_android.cc
+++ b/content/renderer/render_view_impl_android.cc
@@ -4,13 +4,19 @@
 
 #include "content/renderer/render_view_impl.h"
 
+#include "base/command_line.h"
 #include "base/message_loop.h"
+#include "cc/switches.h"
 #include "content/common/view_messages.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebFrame.h"
 
 namespace content {
 
 void RenderViewImpl::ScheduleUpdateFrameInfo() {
+  if (CommandLine::ForCurrentProcess()->HasSwitch(
+      cc::switches::kEnableCompositorFrameMessage))
+    return;
+
   if (update_frame_info_scheduled_)
     return;
   update_frame_info_scheduled_ = true;
@@ -20,6 +26,10 @@ void RenderViewImpl::ScheduleUpdateFrameInfo() {
 }
 
 void RenderViewImpl::SendUpdateFrameInfo() {
+  if (CommandLine::ForCurrentProcess()->HasSwitch(
+      cc::switches::kEnableCompositorFrameMessage))
+    return;
+
   update_frame_info_scheduled_ = false;
 
   if (!webview() || !webview()->mainFrame())