Construct and initialize compositor view in content

This extracts the WebLayerTreeView initialization code out of RenderWidget
and creates a new class, RenderWidgetCompositor, to handle initialization.

BUG=


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

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

9 files changed, 491 insertions, 44 deletions

diff --git a/content/content_renderer.gypi b/content/content_renderer.gypi
index 945f83f..0ff9db0 100644
--- a/content/content_renderer.gypi
+++ b/content/content_renderer.gypi
@@ -100,6 +100,8 @@
     'renderer/gpu/gpu_benchmarking_extension.h',
     'renderer/gpu/stream_texture_host_android.cc',
     'renderer/gpu/stream_texture_host_android.h',
+    'renderer/gpu/render_widget_compositor.cc',
+    'renderer/gpu/render_widget_compositor.h',
     'renderer/hyphenator/hyphenator.cc',
     'renderer/hyphenator/hyphenator.h',
     'renderer/idle_user_detector.cc',
diff --git a/content/renderer/gpu/render_widget_compositor.cc b/content/renderer/gpu/render_widget_compositor.cc
new file mode 100644
index 0000000..32ac46a
--- /dev/null
+++ b/content/renderer/gpu/render_widget_compositor.cc
@@ -0,0 +1,333 @@
+// Copyright (c) 2013 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 "content/renderer/gpu/render_widget_compositor.h"
+
+#include "base/command_line.h"
+#include "base/logging.h"
+#include "base/string_number_conversions.h"
+#include "base/time.h"
+#include "cc/font_atlas.h"
+#include "cc/layer.h"
+#include "cc/layer_tree_debug_state.h"
+#include "cc/layer_tree_host.h"
+#include "cc/switches.h"
+#include "cc/thread_impl.h"
+#include "content/renderer/gpu/compositor_thread.h"
+#include "content/renderer/render_thread_impl.h"
+#include "third_party/WebKit/Source/Platform/chromium/public/WebLayerTreeViewClient.h"
+#include "third_party/WebKit/Source/Platform/chromium/public/WebSize.h"
+#include "webkit/compositor_bindings/web_layer_impl.h"
+#include "webkit/compositor_bindings/web_to_ccinput_handler_adapter.h"
+
+namespace cc {
+class Layer;
+}
+
+using WebKit::WebFloatPoint;
+using WebKit::WebSize;
+using WebKit::WebRect;
+
+namespace content {
+
+// static
+scoped_ptr<RenderWidgetCompositor> RenderWidgetCompositor::Create(
+      RenderWidget* widget,
+      WebKit::WebLayerTreeViewClient* client,
+      WebKit::WebLayerTreeView::Settings web_settings) {
+  scoped_ptr<RenderWidgetCompositor> comp(
+      new RenderWidgetCompositor(widget, client));
+
+  cc::LayerTreeSettings settings;
+  settings.acceleratePainting = web_settings.acceleratePainting;
+  settings.renderVSyncEnabled = web_settings.renderVSyncEnabled;
+  settings.perTilePaintingEnabled = web_settings.perTilePaintingEnabled;
+  settings.rightAlignedSchedulingEnabled =
+    CommandLine::ForCurrentProcess()->HasSwitch(
+        cc::switches::kEnableRightAlignedScheduling);
+  settings.acceleratedAnimationEnabled =
+    web_settings.acceleratedAnimationEnabled;
+  settings.pageScalePinchZoomEnabled = web_settings.pageScalePinchZoomEnabled;
+  settings.refreshRate = web_settings.refreshRate;
+  settings.defaultTileSize = web_settings.defaultTileSize;
+  settings.maxUntiledLayerSize = web_settings.maxUntiledLayerSize;
+  settings.initialDebugState.showFPSCounter = web_settings.showFPSCounter;
+  settings.initialDebugState.showPaintRects = web_settings.showPaintRects;
+  settings.initialDebugState.showPlatformLayerTree =
+    web_settings.showPlatformLayerTree;
+  settings.initialDebugState.showDebugBorders = web_settings.showDebugBorders;
+  settings.implSidePainting =
+    CommandLine::ForCurrentProcess()->HasSwitch(
+        cc::switches::kEnableImplSidePainting);
+  settings.recordRenderingStats = web_settings.recordRenderingStats;
+  settings.useCheapnessEstimator =
+    CommandLine::ForCurrentProcess()->HasSwitch(
+        cc::switches::kUseCheapnessEstimator);
+
+  settings.calculateTopControlsPosition =
+    CommandLine::ForCurrentProcess()->HasSwitch(
+        cc::switches::kEnableTopControlsPositionCalculation);
+  if (CommandLine::ForCurrentProcess()->HasSwitch(
+        cc::switches::kTopControlsHeight)) {
+      std::string controls_height_str =
+        CommandLine::ForCurrentProcess()->GetSwitchValueASCII(
+            cc::switches::kTopControlsHeight);
+      double controls_height;
+      if (base::StringToDouble(controls_height_str, &controls_height) &&
+          controls_height > 0)
+        settings.topControlsHeight = controls_height;
+  }
+  if (settings.calculateTopControlsPosition &&
+      (settings.topControlsHeight <= 0 || !settings.compositorFrameMessage)) {
+    DCHECK(false) << "Top controls repositioning enabled without valid height "
+                     "or compositorFrameMessage set.";
+    settings.calculateTopControlsPosition = false;
+  }
+
+  if (!comp->initialize(settings))
+    return scoped_ptr<RenderWidgetCompositor>();
+
+  return comp.Pass();
+}
+
+RenderWidgetCompositor::RenderWidgetCompositor(
+    RenderWidget* widget, WebKit::WebLayerTreeViewClient* client)
+  : widget_(widget),
+    client_(client) {
+}
+
+RenderWidgetCompositor::~RenderWidgetCompositor() {}
+
+bool RenderWidgetCompositor::initialize(cc::LayerTreeSettings settings) {
+  scoped_ptr<cc::Thread> impl_thread;
+  CompositorThread* compositor_thread =
+      RenderThreadImpl::current()->compositor_thread();
+  threaded_ = !!compositor_thread;
+  if (compositor_thread)
+    impl_thread = cc::ThreadImpl::createForDifferentThread(
+        compositor_thread->message_loop()->message_loop_proxy());
+  layer_tree_host_ = cc::LayerTreeHost::create(this,
+                                               settings,
+                                               impl_thread.Pass());
+  return layer_tree_host_;
+}
+
+void RenderWidgetCompositor::setSurfaceReady() {
+  layer_tree_host_->setSurfaceReady();
+}
+
+void RenderWidgetCompositor::setRootLayer(const WebKit::WebLayer& layer) {
+  layer_tree_host_->setRootLayer(
+      static_cast<const WebKit::WebLayerImpl*>(&layer)->layer());
+}
+
+void RenderWidgetCompositor::clearRootLayer() {
+  layer_tree_host_->setRootLayer(scoped_refptr<cc::Layer>());
+}
+
+void RenderWidgetCompositor::setViewportSize(
+    const WebSize& layout_viewport_size,
+    const WebSize& device_viewport_size) {
+  layer_tree_host_->setViewportSize(layout_viewport_size, device_viewport_size);
+}
+
+WebSize RenderWidgetCompositor::layoutViewportSize() const {
+  return layer_tree_host_->layoutViewportSize();
+}
+
+WebSize RenderWidgetCompositor::deviceViewportSize() const {
+  return layer_tree_host_->deviceViewportSize();
+}
+
+WebFloatPoint RenderWidgetCompositor::adjustEventPointForPinchZoom(
+    const WebFloatPoint& point) const {
+  return point;
+}
+
+void RenderWidgetCompositor::setDeviceScaleFactor(float device_scale) {
+  layer_tree_host_->setDeviceScaleFactor(device_scale);
+}
+
+float RenderWidgetCompositor::deviceScaleFactor() const {
+  return layer_tree_host_->deviceScaleFactor();
+}
+
+void RenderWidgetCompositor::setBackgroundColor(WebKit::WebColor color) {
+  layer_tree_host_->setBackgroundColor(color);
+}
+
+void RenderWidgetCompositor::setHasTransparentBackground(bool transparent) {
+  layer_tree_host_->setHasTransparentBackground(transparent);
+}
+
+void RenderWidgetCompositor::setVisible(bool visible) {
+  layer_tree_host_->setVisible(visible);
+}
+
+void RenderWidgetCompositor::setPageScaleFactorAndLimits(
+    float page_scale_factor, float minimum, float maximum) {
+  layer_tree_host_->setPageScaleFactorAndLimits(
+      page_scale_factor, minimum, maximum);
+}
+
+void RenderWidgetCompositor::startPageScaleAnimation(
+    const WebKit::WebPoint& destination,
+    bool use_anchor,
+    float new_page_scale,
+    double duration_sec) {
+  base::TimeDelta duration = base::TimeDelta::FromMicroseconds(
+      duration_sec * base::Time::kMicrosecondsPerSecond);
+  layer_tree_host_->startPageScaleAnimation(
+      gfx::Vector2d(destination.x, destination.y),
+      use_anchor,
+      new_page_scale,
+      duration);
+}
+
+void RenderWidgetCompositor::setNeedsAnimate() {
+  layer_tree_host_->setNeedsAnimate();
+}
+
+void RenderWidgetCompositor::setNeedsRedraw() {
+  if (threaded_)
+    layer_tree_host_->setNeedsAnimate();
+  else
+    widget_->scheduleAnimation();
+}
+
+bool RenderWidgetCompositor::commitRequested() const {
+  return layer_tree_host_->commitRequested();
+}
+
+void RenderWidgetCompositor::composite() {
+  layer_tree_host_->composite();
+}
+
+void RenderWidgetCompositor::updateAnimations(double frame_begin_time_sec) {
+  base::TimeTicks frame_begin_time =
+    base::TimeTicks::FromInternalValue(frame_begin_time_sec *
+                                       base::Time::kMicrosecondsPerSecond);
+  layer_tree_host_->updateAnimations(frame_begin_time);
+}
+
+void RenderWidgetCompositor::didStopFlinging() {
+  layer_tree_host_->didStopFlinging();
+}
+
+bool RenderWidgetCompositor::compositeAndReadback(void *pixels,
+                                                  const WebRect& rect) {
+  return layer_tree_host_->compositeAndReadback(pixels, rect);
+}
+
+void RenderWidgetCompositor::finishAllRendering() {
+  layer_tree_host_->finishAllRendering();
+}
+
+void RenderWidgetCompositor::setDeferCommits(bool defer_commits) {
+  layer_tree_host_->setDeferCommits(defer_commits);
+}
+
+void RenderWidgetCompositor::setShowFPSCounter(bool show) {
+  cc::LayerTreeDebugState debug_state = layer_tree_host_->debugState();
+  debug_state.showFPSCounter = show;
+  layer_tree_host_->setDebugState(debug_state);
+}
+
+void RenderWidgetCompositor::setShowPaintRects(bool show) {
+  cc::LayerTreeDebugState debug_state = layer_tree_host_->debugState();
+  debug_state.showPaintRects = show;
+  layer_tree_host_->setDebugState(debug_state);
+}
+
+void RenderWidgetCompositor::setContinuousPaintingEnabled(bool enabled) {
+  cc::LayerTreeDebugState debug_state = layer_tree_host_->debugState();
+  debug_state.continuousPainting = enabled;
+  layer_tree_host_->setDebugState(debug_state);
+}
+
+// TODO(jamesr): This should go through WebWidget.
+void RenderWidgetCompositor::willBeginFrame() {
+  client_->willBeginFrame();
+}
+
+// TODO(jamesr): This should go through WebWidget.
+void RenderWidgetCompositor::didBeginFrame() {
+  client_->didBeginFrame();
+}
+
+void RenderWidgetCompositor::animate(double monotonic_frame_begin_time) {
+  client_->updateAnimations(monotonic_frame_begin_time);
+}
+
+// Can delete from WebLayerTreeViewClient
+void RenderWidgetCompositor::layout() {
+  widget_->webwidget()->layout();
+}
+
+// TODO(jamesr): This should go through WebWidget.
+void RenderWidgetCompositor::applyScrollAndScale(gfx::Vector2d scroll_delta,
+                                                 float page_scale) {
+  client_->applyScrollAndScale(scroll_delta, page_scale);
+}
+
+scoped_ptr<cc::OutputSurface> RenderWidgetCompositor::createOutputSurface() {
+  return widget_->CreateOutputSurface();
+}
+
+// TODO(jamesr): This should go through WebWidget
+void RenderWidgetCompositor::didRecreateOutputSurface(bool success) {
+  client_->didRecreateOutputSurface(success);
+}
+
+// TODO(jamesr): This should go through WebWidget
+scoped_ptr<cc::InputHandler> RenderWidgetCompositor::createInputHandler() {
+  scoped_ptr<cc::InputHandler> ret;
+  scoped_ptr<WebKit::WebInputHandler> web_handler(
+      client_->createInputHandler());
+  if (web_handler)
+     ret = WebKit::WebToCCInputHandlerAdapter::create(web_handler.Pass());
+  return ret.Pass();
+}
+
+// TODO(jamesr): This should go through WebWidget
+void RenderWidgetCompositor::willCommit() {
+  client_->willCommit();
+}
+
+void RenderWidgetCompositor::didCommit() {
+  // TODO(jamesr): There is no chromium-side implementation of this first call,
+  // remove if it's not needed.
+  widget_->didCommitCompositorFrame();
+  widget_->didBecomeReadyForAdditionalInput();
+}
+
+void RenderWidgetCompositor::didCommitAndDrawFrame() {
+  widget_->didCommitAndDrawCompositorFrame();
+}
+
+void RenderWidgetCompositor::didCompleteSwapBuffers() {
+  widget_->didCompleteSwapBuffers();
+}
+
+// TODO(jamesr): This goes through WebViewImpl just to do suppression, refactor
+// that piece out.
+void RenderWidgetCompositor::scheduleComposite() {
+  client_->scheduleComposite();
+}
+
+scoped_ptr<cc::FontAtlas> RenderWidgetCompositor::createFontAtlas() {
+  int font_height;
+  WebRect ascii_to_web_rect_table[128];
+  gfx::Rect ascii_to_rect_table[128];
+  SkBitmap bitmap;
+
+  client_->createFontAtlas(bitmap, ascii_to_web_rect_table, font_height);
+
+  for (int i = 0; i < 128; ++i)
+    ascii_to_rect_table[i] = ascii_to_web_rect_table[i];
+
+  return cc::FontAtlas::create(bitmap, ascii_to_rect_table, font_height).Pass();
+}
+
+}  // namespace content
diff --git a/content/renderer/gpu/render_widget_compositor.h b/content/renderer/gpu/render_widget_compositor.h
new file mode 100644
index 0000000..d3ff550
--- /dev/null
+++ b/content/renderer/gpu/render_widget_compositor.h
@@ -0,0 +1,102 @@
+// Copyright (c) 2013 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 CONTENT_RENDERER_GPU_RENDER_WIDGET_COMPOSITOR_H_
+#define CONTENT_RENDERER_GPU_RENDER_WIDGET_COMPOSITOR_H_
+
+#include "cc/layer_tree_host_client.h"
+#include "cc/layer_tree_settings.h"
+#include "third_party/WebKit/Source/Platform/chromium/public/WebLayerTreeView.h"
+
+namespace cc {
+class LayerTreeHost;
+}
+
+namespace content {
+class RenderWidget;
+
+class RenderWidgetCompositor : public WebKit::WebLayerTreeView,
+                               public cc::LayerTreeHostClient {
+ public:
+  // Attempt to construct and initialize a compositor instance for the widget
+  // with the given settings. Returns NULL if initialization fails.
+  static scoped_ptr<RenderWidgetCompositor> Create(
+      RenderWidget* widget,
+      WebKit::WebLayerTreeViewClient* client,
+      WebKit::WebLayerTreeView::Settings settings);
+
+  virtual ~RenderWidgetCompositor();
+
+  cc::LayerTreeHost* layer_tree_host() const { return layer_tree_host_.get(); }
+
+  // WebLayerTreeView implementation.
+  virtual void setSurfaceReady();
+  virtual void setRootLayer(const WebKit::WebLayer& layer);
+  virtual void clearRootLayer();
+  virtual void setViewportSize(
+      const WebKit::WebSize& layout_viewport_size,
+      const WebKit::WebSize& device_viewport_size);
+  virtual WebKit::WebSize layoutViewportSize() const;
+  virtual WebKit::WebSize deviceViewportSize() const;
+  virtual WebKit::WebFloatPoint adjustEventPointForPinchZoom(
+      const WebKit::WebFloatPoint& point) const;
+  virtual void setDeviceScaleFactor(float device_scale);
+  virtual float deviceScaleFactor() const;
+  virtual void setBackgroundColor(WebKit::WebColor color);
+  virtual void setHasTransparentBackground(bool transparent);
+  virtual void setVisible(bool visible);
+  virtual void setPageScaleFactorAndLimits(float page_scale_factor,
+                                           float minimum,
+                                           float maximum);
+  virtual void startPageScaleAnimation(const WebKit::WebPoint& destination,
+                                       bool use_anchor,
+                                       float new_page_scale,
+                                       double duration_sec);
+  virtual void setNeedsAnimate();
+  virtual void setNeedsRedraw();
+  virtual bool commitRequested() const;
+  virtual void composite();
+  virtual void updateAnimations(double frame_begin_time);
+  virtual void didStopFlinging();
+  virtual bool compositeAndReadback(void *pixels, const WebKit::WebRect& rect);
+  virtual void finishAllRendering();
+  virtual void setDeferCommits(bool defer_commits);
+  virtual void renderingStats(WebKit::WebRenderingStats& stats) const {}
+  virtual void setShowFPSCounter(bool show);
+  virtual void setShowPaintRects(bool show);
+  virtual void setContinuousPaintingEnabled(bool enabled);
+
+  // cc::LayerTreeHostClient implementation.
+  virtual void willBeginFrame() OVERRIDE;
+  virtual void didBeginFrame() OVERRIDE;
+  virtual void animate(double monotonic_frame_begin_time) OVERRIDE;
+  virtual void layout() OVERRIDE;
+  virtual void applyScrollAndScale(gfx::Vector2d scroll_delta,
+                                   float page_scale) OVERRIDE;
+  virtual scoped_ptr<cc::OutputSurface> createOutputSurface() OVERRIDE;
+  virtual void didRecreateOutputSurface(bool success) OVERRIDE;
+  virtual scoped_ptr<cc::InputHandler> createInputHandler() OVERRIDE;
+  virtual void willCommit() OVERRIDE;
+  virtual void didCommit() OVERRIDE;
+  virtual void didCommitAndDrawFrame() OVERRIDE;
+  virtual void didCompleteSwapBuffers() OVERRIDE;
+  virtual void scheduleComposite() OVERRIDE;
+  virtual scoped_ptr<cc::FontAtlas> createFontAtlas() OVERRIDE;
+
+private:
+  RenderWidgetCompositor(RenderWidget* widget,
+                         WebKit::WebLayerTreeViewClient* client);
+
+  bool initialize(cc::LayerTreeSettings settings);
+
+  bool threaded_;
+  RenderWidget* widget_;
+  WebKit::WebLayerTreeViewClient* client_;
+  scoped_ptr<cc::LayerTreeHost> layer_tree_host_;
+};
+
+}  // namespace content
+
+#endif  // CONTENT_RENDERER_GPU_RENDER_WIDGET_COMPOSITOR_H_
+
diff --git a/content/renderer/render_view_impl.cc b/content/renderer/render_view_impl.cc
index bc1030e..e15789b 100644
--- a/content/renderer/render_view_impl.cc
+++ b/content/renderer/render_view_impl.cc
@@ -79,6 +79,7 @@
 #include "content/renderer/gpu/compositor_thread.h"
 #include "content/renderer/gpu/compositor_output_surface.h"
 #include "content/renderer/gpu/compositor_software_output_device_gl_adapter.h"
+#include "content/renderer/gpu/render_widget_compositor.h"
 #include "content/renderer/idle_user_detector.h"
 #include "content/renderer/input_tag_speech_dispatcher.h"
 #include "content/renderer/java/java_bridge_dispatcher.h"
@@ -1971,7 +1972,7 @@ WebStorageNamespace* RenderViewImpl::createSessionStorageNamespace(
   return new WebStorageNamespaceImpl(session_storage_namespace_id_);
 }
 
-WebKit::WebCompositorOutputSurface* RenderViewImpl::createOutputSurface() {
+scoped_ptr<cc::OutputSurface> RenderViewImpl::CreateOutputSurface() {
   // Explicitly disable antialiasing for the compositor. As of the time of
   // this writing, the only platform that supported antialiasing for the
   // compositor was Mac OS X, because the on-screen OpenGL context creation
@@ -1988,20 +1989,27 @@ WebKit::WebCompositorOutputSurface* RenderViewImpl::createOutputSurface() {
   attributes.noAutomaticFlushes = true;
   WebGraphicsContext3D* context = CreateGraphicsContext3D(attributes);
   if (!context)
-    return NULL;
+    return scoped_ptr<cc::OutputSurface>();
 
   const CommandLine& command_line = *CommandLine::ForCurrentProcess();
   if (command_line.HasSwitch(switches::kEnableSoftwareCompositingGLAdapter)) {
       // In the absence of a software-based delegating renderer, use this
       // stopgap adapter class to present the software renderer output using a
       // 3d context.
-      return new CompositorOutputSurface(routing_id(), NULL,
-          new CompositorSoftwareOutputDeviceGLAdapter(context));
+      return scoped_ptr<cc::OutputSurface>(
+          new CompositorOutputSurface(routing_id(), NULL,
+              new CompositorSoftwareOutputDeviceGLAdapter(context)));
   } else {
-      return new CompositorOutputSurface(routing_id(), context, NULL);
+      return scoped_ptr<cc::OutputSurface>(
+          new CompositorOutputSurface(routing_id(), context, NULL));
   }
 }
 
+WebKit::WebCompositorOutputSurface* RenderViewImpl::createOutputSurface() {
+  NOTREACHED();
+  return NULL;
+}
+
 void RenderViewImpl::didAddMessageToConsole(
     const WebConsoleMessage& message, const WebString& source_name,
     unsigned source_line) {
@@ -5798,8 +5806,8 @@ void RenderViewImpl::OnClearFocusedNode() {
 void RenderViewImpl::OnSetBackground(const SkBitmap& background) {
   if (webview())
     webview()->setIsTransparent(!background.empty());
-  if (web_layer_tree_view_)
-    web_layer_tree_view_->setHasTransparentBackground(!background.empty());
+  if (compositor_)
+    compositor_->setHasTransparentBackground(!background.empty());
 
   SetBackground(background);
 }
@@ -5989,7 +5997,7 @@ void RenderViewImpl::OnWasShown(bool needs_repainting) {
 
 bool RenderViewImpl::SupportsAsynchronousSwapBuffers() {
   // Contexts using the command buffer support asynchronous swapbuffers.
-  // See RenderViewImpl::createOutputSurface().
+  // See RenderViewImpl::CreateOutputSurface().
   if (RenderThreadImpl::current()->compositor_thread() ||
       CommandLine::ForCurrentProcess()->HasSwitch(switches::kInProcessWebGL))
     return false;
diff --git a/content/renderer/render_view_impl.h b/content/renderer/render_view_impl.h
index 7de0419..82edc31 100644
--- a/content/renderer/render_view_impl.h
+++ b/content/renderer/render_view_impl.h
@@ -794,6 +794,7 @@ class CONTENT_EXPORT RenderViewImpl
   virtual void OnWasShown(bool needs_repainting) OVERRIDE;
   virtual bool SupportsAsynchronousSwapBuffers() OVERRIDE;
   virtual bool ForceCompositingModeEnabled() OVERRIDE;
+  virtual scoped_ptr<cc::OutputSurface> CreateOutputSurface() OVERRIDE;
   virtual void OnImeSetComposition(
       const string16& text,
       const std::vector<WebKit::WebCompositionUnderline>& underlines,
diff --git a/content/renderer/render_widget.cc b/content/renderer/render_widget.cc
index 6cfeabe..851c34a 100644
--- a/content/renderer/render_widget.cc
+++ b/content/renderer/render_widget.cc
@@ -21,6 +21,7 @@
 #include "content/common/view_messages.h"
 #include "content/public/common/content_switches.h"
 #include "content/renderer/gpu/compositor_thread.h"
+#include "content/renderer/gpu/render_widget_compositor.h"
 #include "content/renderer/render_process.h"
 #include "content/renderer/render_thread_impl.h"
 #include "content/renderer/renderer_webkitplatformsupport_impl.h"
@@ -253,8 +254,8 @@ void RenderWidget::CompleteInit() {
   if (webwidget_ && is_threaded_compositing_enabled_) {
     webwidget_->enterForceCompositingMode(true);
   }
-  if (web_layer_tree_view_) {
-    web_layer_tree_view_->setSurfaceReady();
+  if (compositor_) {
+    compositor_->setSurfaceReady();
   }
   DoDeferredUpdate();
 
@@ -512,6 +513,10 @@ bool RenderWidget::ForceCompositingModeEnabled() {
   return false;
 }
 
+scoped_ptr<cc::OutputSurface> RenderWidget::CreateOutputSurface() {
+  return scoped_ptr<cc::OutputSurface>();
+}
+
 void RenderWidget::OnSwapBuffersAborted() {
   TRACE_EVENT0("renderer", "RenderWidget::OnSwapBuffersAborted");
   while (!updates_pending_swap_.empty()) {
@@ -676,8 +681,8 @@ void RenderWidget::OnHandleInputEvent(const WebKit::WebInputEvent* input_event,
 
   bool frame_pending = paint_aggregator_.HasPendingUpdate();
   if (is_accelerated_compositing_active_) {
-    frame_pending = web_layer_tree_view_ &&
-                    web_layer_tree_view_->commitRequested();
+    frame_pending = compositor_ &&
+                    compositor_->commitRequested();
   }
 
   bool is_input_throttled =
@@ -913,8 +918,8 @@ void RenderWidget::AnimateIfNeeded() {
     animation_timer_.Start(FROM_HERE, animationInterval, this,
                            &RenderWidget::AnimationCallback);
     animation_update_pending_ = false;
-    if (is_accelerated_compositing_active_ && web_layer_tree_view_) {
-      web_layer_tree_view_->layer_tree_host()->updateAnimations(
+    if (is_accelerated_compositing_active_ && compositor_) {
+      compositor_->layer_tree_host()->updateAnimations(
           base::TimeTicks::Now());
     } else {
       webwidget_->animate(0.0);
@@ -1173,8 +1178,8 @@ void RenderWidget::DoDeferredUpdate() {
 
 void RenderWidget::Composite() {
   DCHECK(is_accelerated_compositing_active_);
-  if (web_layer_tree_view_)  // TODO(jamesr): Figure out how this can be null.
-    web_layer_tree_view_->composite();
+  if (compositor_)  // TODO(jamesr): Figure out how this can be null.
+    compositor_->composite();
 }
 
 ///////////////////////////////////////////////////////////////////////////////
@@ -1315,27 +1320,17 @@ void RenderWidget::initializeLayerTreeView(
     WebKit::WebLayerTreeViewClient* client,
     const WebKit::WebLayer& root_layer,
     const WebKit::WebLayerTreeView::Settings& settings) {
-  DCHECK(!web_layer_tree_view_);
-  web_layer_tree_view_.reset(new WebKit::WebLayerTreeViewImpl(client));
-
-  scoped_ptr<cc::Thread> impl_thread;
-  CompositorThread* compositor_thread =
-      RenderThreadImpl::current()->compositor_thread();
-  if (compositor_thread)
-    impl_thread = cc::ThreadImpl::createForDifferentThread(
-        compositor_thread->message_loop()->message_loop_proxy());
-  if (!web_layer_tree_view_->initialize(settings, impl_thread.Pass())) {
-    web_layer_tree_view_.reset();
+  compositor_ = RenderWidgetCompositor::Create(this, client, settings);
+  if (!compositor_)
     return;
-  }
-  web_layer_tree_view_->setRootLayer(root_layer);
-  if (init_complete_) {
-    web_layer_tree_view_->setSurfaceReady();
-  }
+
+  compositor_->setRootLayer(root_layer);
+  if (init_complete_)
+    compositor_->setSurfaceReady();
 }
 
 WebKit::WebLayerTreeView* RenderWidget::layerTreeView() {
-  return web_layer_tree_view_.get();
+  return compositor_.get();
 }
 
 void RenderWidget::willBeginCompositorFrame() {
@@ -1400,8 +1395,8 @@ void RenderWidget::didCompleteSwapBuffers() {
 void RenderWidget::scheduleComposite() {
   TRACE_EVENT0("gpu", "RenderWidget::scheduleComposite");
   if (RenderThreadImpl::current()->compositor_thread() &&
-      web_layer_tree_view_) {
-    web_layer_tree_view_->setNeedsRedraw();
+      compositor_) {
+    compositor_->setNeedsRedraw();
   } else {
     // TODO(nduca): replace with something a little less hacky.  The reason this
     // hack is still used is because the Invalidate-DoDeferredUpdate loop
@@ -1493,7 +1488,7 @@ void RenderWidget::closeWidgetSoon() {
 void RenderWidget::Close() {
   if (webwidget_) {
     webwidget_->willCloseLayerTreeView();
-    web_layer_tree_view_.reset();
+    compositor_.reset();
     webwidget_->close();
     webwidget_ = NULL;
   }
@@ -1708,8 +1703,8 @@ void RenderWidget::OnRepaint(const gfx::Size& size_to_paint) {
 
   set_next_paint_is_repaint_ack();
   if (is_accelerated_compositing_active_) {
-    if (web_layer_tree_view_)
-      web_layer_tree_view_->setNeedsRedraw();
+    if (compositor_)
+      compositor_->setNeedsRedraw();
     scheduleComposite();
   } else {
     gfx::Rect repaint_rect(size_to_paint.width(), size_to_paint.height());
@@ -2053,8 +2048,8 @@ void RenderWidget::CleanupWindowInPluginMoves(gfx::PluginWindowHandle window) {
 
 void RenderWidget::GetRenderingStats(
     WebKit::WebRenderingStatsImpl& stats) const {
-  if (web_layer_tree_view_)
-    web_layer_tree_view_->renderingStats(stats);
+  if (compositor_)
+    compositor_->layer_tree_host()->renderingStats(&stats.rendering_stats);
 
   stats.rendering_stats.numAnimationFrames +=
       software_stats_.numAnimationFrames;
diff --git a/content/renderer/render_widget.h b/content/renderer/render_widget.h
index d710f99..725bdc5 100644
--- a/content/renderer/render_widget.h
+++ b/content/renderer/render_widget.h
@@ -51,6 +51,8 @@ struct WebPoint;
 class WebTouchEvent;
 }
 
+namespace cc { class OutputSurface; }
+
 namespace ui {
 class Range;
 }
@@ -67,6 +69,7 @@ class PluginInstance;
 
 namespace content {
 struct GpuRenderingStats;
+class RenderWidgetCompositor;
 class RenderWidgetTest;
 
 // RenderWidget provides a communication bridge between a WebWidget and
@@ -170,6 +173,8 @@ class CONTENT_EXPORT RenderWidget
   // This call is relatively expensive as it blocks on the GPU process
   bool GetGpuRenderingStats(GpuRenderingStats*) const;
 
+  virtual scoped_ptr<cc::OutputSurface> CreateOutputSurface();
+
   // Callback for use with BeginSmoothScroll.
   typedef base::Callback<void()> SmoothScrollCompletionCallback;
 
@@ -456,7 +461,7 @@ class CONTENT_EXPORT RenderWidget
   WebKit::WebWidget* webwidget_;
 
   // This is lazily constructed and must not outlive webwidget_.
-  scoped_ptr<WebKit::WebLayerTreeViewImpl> web_layer_tree_view_;
+  scoped_ptr<RenderWidgetCompositor> compositor_;
 
   // Set to the ID of the view that initiated creating this view, if any. When
   // the view was initiated by the browser (the common case), this will be
diff --git a/webkit/compositor_bindings/web_layer_impl.h b/webkit/compositor_bindings/web_layer_impl.h
index 5e159d9..af77caf 100644
--- a/webkit/compositor_bindings/web_layer_impl.h
+++ b/webkit/compositor_bindings/web_layer_impl.h
@@ -24,6 +24,8 @@ public:
     WEBKIT_COMPOSITOR_BINDINGS_EXPORT explicit WebLayerImpl(scoped_refptr<cc::Layer>);
     virtual ~WebLayerImpl();
 
+    WEBKIT_COMPOSITOR_BINDINGS_EXPORT cc::Layer* layer() const;
+
     // WebLayer implementation.
     virtual int id() const OVERRIDE;
     virtual void invalidateRect(const WebFloatRect&) OVERRIDE;
@@ -95,8 +97,6 @@ public:
     virtual bool fixedToContainerLayer() const;
     virtual void setScrollClient(WebLayerScrollClient*) OVERRIDE;
 
-    cc::Layer* layer() const;
-
 protected:
     scoped_refptr<cc::Layer> m_layer;
 };
diff --git a/webkit/compositor_bindings/web_to_ccinput_handler_adapter.h b/webkit/compositor_bindings/web_to_ccinput_handler_adapter.h
index f8462c7..cf2c112 100644
--- a/webkit/compositor_bindings/web_to_ccinput_handler_adapter.h
+++ b/webkit/compositor_bindings/web_to_ccinput_handler_adapter.h
@@ -8,12 +8,13 @@
 #include "base/memory/scoped_ptr.h"
 #include "cc/input_handler.h"
 #include "third_party/WebKit/Source/Platform/chromium/public/WebInputHandler.h"
+#include "webkit/compositor_bindings/webkit_compositor_bindings_export.h"
 
 namespace WebKit {
 
 class WebToCCInputHandlerAdapter : public cc::InputHandler {
 public:
-    static scoped_ptr<WebToCCInputHandlerAdapter> create(scoped_ptr<WebInputHandler>);
+    WEBKIT_COMPOSITOR_BINDINGS_EXPORT static scoped_ptr<WebToCCInputHandlerAdapter> create(scoped_ptr<WebInputHandler>);
     virtual ~WebToCCInputHandlerAdapter();
 
     // cc::InputHandler implementation.