Composite to cc::Display from ui::InProcessContextFactory.

The trees this composites may contain SurfaceLayers, so they have to be aggregated into a Display before being drawn. Also move OnscreenDisplayClient and SurfaceDisplayOutputSurface into cc/surfaces/ so they can be used by ui/compositor.

Review URL: https://codereview.chromium.org/888783002

Cr-Commit-Position: refs/heads/master@{#314269}

cc/cc.gyp

@@ -589,6 +589,8 @@
         'surfaces/display.cc',
         'surfaces/display.h',
         'surfaces/display_client.h',
+        'surfaces/onscreen_display_client.cc',
+        'surfaces/onscreen_display_client.h',
         'surfaces/surface.cc',
         'surfaces/surface.h',
         'surfaces/surface_aggregator.cc',
@@ -599,6 +601,8 @@
         'surfaces/surface_id.h',
         'surfaces/surface_id_allocator.cc',
         'surfaces/surface_id_allocator.h',
+        'surfaces/surface_display_output_surface.cc',
+        'surfaces/surface_display_output_surface.h',
         'surfaces/surface_manager.cc',
         'surfaces/surface_manager.h',
         'surfaces/surface_resource_holder.cc',

cc/surfaces/BUILD.gn

@@ -18,10 +18,14 @@ component("surfaces") {
     "display.cc",
     "display.h",
     "display_client.h",
+    "onscreen_display_client.cc",
+    "onscreen_display_client.h",
     "surface.cc",
     "surface.h",
     "surface_aggregator.cc",
     "surface_aggregator.h",
+    "surface_display_output_surface.cc",
+    "surface_display_output_surface.h",
     "surface_factory.cc",
     "surface_factory.h",
     "surface_factory_client.h",

cc/surfaces/onscreen_display_client.cc

@@ -2,28 +2,28 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#include "content/browser/compositor/onscreen_display_client.h"
+#include "cc/surfaces/onscreen_display_client.h"
 
 #include "base/trace_event/trace_event.h"
 #include "cc/output/output_surface.h"
+#include "cc/surfaces/surface_display_output_surface.h"
 #include "cc/surfaces/surface_factory.h"
 #include "cc/surfaces/surface_manager.h"
-#include "content/browser/compositor/surface_display_output_surface.h"
-#include "content/browser/gpu/browser_gpu_memory_buffer_manager.h"
-#include "content/common/host_shared_bitmap_manager.h"
 
-namespace content {
+namespace cc {
 
 OnscreenDisplayClient::OnscreenDisplayClient(
-    scoped_ptr<cc::OutputSurface> output_surface,
-    cc::SurfaceManager* manager,
-    const cc::RendererSettings& settings,
+    scoped_ptr<OutputSurface> output_surface,
+    SurfaceManager* manager,
+    SharedBitmapManager* bitmap_manager,
+    gpu::GpuMemoryBufferManager* gpu_memory_buffer_manager,
+    const RendererSettings& settings,
     scoped_refptr<base::SingleThreadTaskRunner> task_runner)
     : output_surface_(output_surface.Pass()),
-      display_(new cc::Display(this,
+      display_(new Display(this,
                            manager,
-                               HostSharedBitmapManager::current(),
-                               BrowserGpuMemoryBufferManager::current(),
+                           bitmap_manager,
+                           gpu_memory_buffer_manager,
                            settings)),
       task_runner_(task_runner),
       scheduled_draw_(false),
@@ -60,9 +60,8 @@ void OnscreenDisplayClient::ScheduleDraw() {
   DCHECK(!deferred_draw_);
   DCHECK(!scheduled_draw_);
   scheduled_draw_ = true;
-  task_runner_->PostTask(
-      FROM_HERE,
-      base::Bind(&OnscreenDisplayClient::Draw, weak_ptr_factory_.GetWeakPtr()));
+  task_runner_->PostTask(FROM_HERE, base::Bind(&OnscreenDisplayClient::Draw,
+                                               weak_ptr_factory_.GetWeakPtr()));
 }
 
 void OnscreenDisplayClient::OutputSurfaceLost() {
@@ -90,9 +89,8 @@ void OnscreenDisplayClient::DidSwapBuffersComplete() {
   }
 }
 
-void OnscreenDisplayClient::SetMemoryPolicy(
-    const cc::ManagedMemoryPolicy& policy) {
+void OnscreenDisplayClient::SetMemoryPolicy(const ManagedMemoryPolicy& policy) {
   surface_display_output_surface_->SetMemoryPolicy(policy);
 }
 
-}  // namespace content
+}  // namespace cc

cc/surfaces/onscreen_display_client.h

@@ -2,49 +2,51 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#ifndef CONTENT_BROWSER_COMPOSITOR_ONSCREEN_DISPLAY_CLIENT_H_
-#define CONTENT_BROWSER_COMPOSITOR_ONSCREEN_DISPLAY_CLIENT_H_
+#ifndef CC_SURFACES_ONSCREEN_DISPLAY_CLIENT_H_
+#define CC_SURFACES_ONSCREEN_DISPLAY_CLIENT_H_
 
 #include "cc/surfaces/display_client.h"
 
+#include "base/compiler_specific.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/single_thread_task_runner.h"
 #include "cc/surfaces/display.h"
+#include "cc/surfaces/surfaces_export.h"
 
 namespace cc {
 class ContextProvider;
 class SurfaceManager;
-}
-
-namespace content {
 class SurfaceDisplayOutputSurface;
 
 // This class provides a DisplayClient implementation for drawing directly to an
 // onscreen context.
-class OnscreenDisplayClient : cc::DisplayClient {
+class CC_SURFACES_EXPORT OnscreenDisplayClient
+    : NON_EXPORTED_BASE(DisplayClient) {
  public:
   OnscreenDisplayClient(
-      scoped_ptr<cc::OutputSurface> output_surface,
-      cc::SurfaceManager* manager,
-      const cc::RendererSettings& settings,
+      scoped_ptr<OutputSurface> output_surface,
+      SurfaceManager* manager,
+      SharedBitmapManager* bitmap_manager,
+      gpu::GpuMemoryBufferManager* gpu_memory_buffer_manager,
+      const RendererSettings& settings,
       scoped_refptr<base::SingleThreadTaskRunner> task_runner);
   ~OnscreenDisplayClient() override;
 
   bool Initialize();
-  cc::Display* display() { return display_.get(); }
+  Display* display() { return display_.get(); }
   void set_surface_output_surface(SurfaceDisplayOutputSurface* surface) {
     surface_display_output_surface_ = surface;
   }
 
-  // cc::DisplayClient implementation.
+  // DisplayClient implementation.
   void DisplayDamaged() override;
   void DidSwapBuffers() override;
   void DidSwapBuffersComplete() override;
   void CommitVSyncParameters(base::TimeTicks timebase,
                              base::TimeDelta interval) override;
   void OutputSurfaceLost() override;
-  void SetMemoryPolicy(const cc::ManagedMemoryPolicy& policy) override;
+  void SetMemoryPolicy(const ManagedMemoryPolicy& policy) override;
 
   bool output_surface_lost() { return output_surface_lost_; }
 
@@ -52,8 +54,8 @@ class OnscreenDisplayClient : cc::DisplayClient {
   void ScheduleDraw();
   void Draw();
 
-  scoped_ptr<cc::OutputSurface> output_surface_;
-  scoped_ptr<cc::Display> display_;
+  scoped_ptr<OutputSurface> output_surface_;
+  scoped_ptr<Display> display_;
   scoped_refptr<base::SingleThreadTaskRunner> task_runner_;
   SurfaceDisplayOutputSurface* surface_display_output_surface_;
   bool scheduled_draw_;
@@ -68,6 +70,6 @@ class OnscreenDisplayClient : cc::DisplayClient {
   DISALLOW_COPY_AND_ASSIGN(OnscreenDisplayClient);
 };
 
-}  // namespace content
+}  // namespace cc
 
-#endif  // CONTENT_BROWSER_COMPOSITOR_ONSCREEN_DISPLAY_CLIENT_H_
+#endif  // CC_SURFACES_ONSCREEN_DISPLAY_CLIENT_H_

cc/surfaces/surface_display_output_surface.cc

@@ -2,23 +2,22 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#include "content/browser/compositor/surface_display_output_surface.h"
+#include "cc/surfaces/surface_display_output_surface.h"
 
 #include "cc/output/compositor_frame.h"
 #include "cc/output/compositor_frame_ack.h"
 #include "cc/surfaces/display.h"
+#include "cc/surfaces/onscreen_display_client.h"
 #include "cc/surfaces/surface.h"
 #include "cc/surfaces/surface_manager.h"
-#include "content/browser/compositor/onscreen_display_client.h"
 
-namespace content {
+namespace cc {
 
 SurfaceDisplayOutputSurface::SurfaceDisplayOutputSurface(
-    cc::SurfaceManager* surface_manager,
-    cc::SurfaceIdAllocator* allocator,
-    const scoped_refptr<cc::ContextProvider>& context_provider)
-    : cc::OutputSurface(context_provider,
-                        scoped_ptr<cc::SoftwareOutputDevice>()),
+    SurfaceManager* surface_manager,
+    SurfaceIdAllocator* allocator,
+    const scoped_refptr<ContextProvider>& context_provider)
+    : OutputSurface(context_provider, nullptr),
       display_client_(NULL),
       surface_manager_(surface_manager),
       factory_(surface_manager, this),
@@ -41,7 +40,7 @@ void SurfaceDisplayOutputSurface::ReceivedVSyncParameters(
   CommitVSyncParameters(timebase, interval);
 }
 
-void SurfaceDisplayOutputSurface::SwapBuffers(cc::CompositorFrame* frame) {
+void SurfaceDisplayOutputSurface::SwapBuffers(CompositorFrame* frame) {
   gfx::Size frame_size =
       frame->delegated_frame_data->render_pass_list.back()->output_rect.size();
   if (frame_size != display_size_) {
@@ -55,19 +54,17 @@ void SurfaceDisplayOutputSurface::SwapBuffers(cc::CompositorFrame* frame) {
   display_client_->display()->SetSurfaceId(surface_id_,
                                            frame->metadata.device_scale_factor);
 
-  scoped_ptr<cc::CompositorFrame> frame_copy(new cc::CompositorFrame());
+  scoped_ptr<CompositorFrame> frame_copy(new CompositorFrame());
   frame->AssignTo(frame_copy.get());
   factory_.SubmitFrame(
-      surface_id_,
-      frame_copy.Pass(),
+      surface_id_, frame_copy.Pass(),
       base::Bind(&SurfaceDisplayOutputSurface::SwapBuffersComplete,
                  base::Unretained(this)));
 
   client_->DidSwapBuffers();
 }
 
-bool SurfaceDisplayOutputSurface::BindToClient(
-    cc::OutputSurfaceClient* client) {
+bool SurfaceDisplayOutputSurface::BindToClient(OutputSurfaceClient* client) {
   DCHECK(client);
   DCHECK(display_client_);
   client_ = client;
@@ -78,25 +75,24 @@ bool SurfaceDisplayOutputSurface::BindToClient(
 
 void SurfaceDisplayOutputSurface::ForceReclaimResources() {
   if (!surface_id_.is_null()) {
-    scoped_ptr<cc::CompositorFrame> empty_frame(new cc::CompositorFrame());
-    empty_frame->delegated_frame_data.reset(new cc::DelegatedFrameData);
+    scoped_ptr<CompositorFrame> empty_frame(new CompositorFrame());
+    empty_frame->delegated_frame_data.reset(new DelegatedFrameData);
     factory_.SubmitFrame(surface_id_, empty_frame.Pass(),
-                         cc::SurfaceFactory::DrawCallback());
+                         SurfaceFactory::DrawCallback());
   }
 }
 
 void SurfaceDisplayOutputSurface::ReturnResources(
-    const cc::ReturnedResourceArray& resources) {
-  cc::CompositorFrameAck ack;
+    const ReturnedResourceArray& resources) {
+  CompositorFrameAck ack;
   ack.resources = resources;
   if (client_)
     client_->ReclaimResources(&ack);
 }
 
-void SurfaceDisplayOutputSurface::SwapBuffersComplete(
-    cc::SurfaceDrawStatus drawn) {
+void SurfaceDisplayOutputSurface::SwapBuffersComplete(SurfaceDrawStatus drawn) {
   if (client_ && !display_client_->output_surface_lost())
     client_->DidSwapBuffersComplete();
 }
 
-}  // namespace content
+}  // namespace cc

cc/surfaces/surface_display_output_surface.h

@@ -0,0 +1,63 @@
+// Copyright 2014 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_SURFACES_SURFACE_DISPLAY_OUTPUT_SURFACE_H_
+#define CC_SURFACES_SURFACE_DISPLAY_OUTPUT_SURFACE_H_
+
+#include "cc/output/output_surface.h"
+#include "cc/surfaces/surface_factory.h"
+#include "cc/surfaces/surface_factory_client.h"
+#include "cc/surfaces/surface_id_allocator.h"
+#include "cc/surfaces/surfaces_export.h"
+
+namespace cc {
+class Display;
+class OnscreenDisplayClient;
+class SurfaceManager;
+
+// This class is maps a compositor OutputSurface to the surface system's Display
+// concept, allowing a compositor client to submit frames for a native root
+// window or physical display.
+class CC_SURFACES_EXPORT SurfaceDisplayOutputSurface
+    : public OutputSurface,
+      public SurfaceFactoryClient {
+ public:
+  // The underlying Display and SurfaceManager must outlive this class.
+  SurfaceDisplayOutputSurface(
+      SurfaceManager* surface_manager,
+      SurfaceIdAllocator* allocator,
+      const scoped_refptr<ContextProvider>& context_provider);
+  ~SurfaceDisplayOutputSurface() override;
+
+  void set_display_client(OnscreenDisplayClient* display_client) {
+    display_client_ = display_client;
+  }
+  SurfaceFactory* factory() { return &factory_; }
+  void ReceivedVSyncParameters(base::TimeTicks timebase,
+                               base::TimeDelta interval);
+
+  // OutputSurface implementation.
+  void SwapBuffers(CompositorFrame* frame) override;
+  bool BindToClient(OutputSurfaceClient* client) override;
+  void ForceReclaimResources() override;
+
+  // SurfaceFactoryClient implementation.
+  void ReturnResources(const ReturnedResourceArray& resources) override;
+
+ private:
+  void SwapBuffersComplete(SurfaceDrawStatus drawn);
+
+  OnscreenDisplayClient* display_client_;
+  SurfaceManager* surface_manager_;
+  SurfaceFactory factory_;
+  gfx::Size display_size_;
+  SurfaceId surface_id_;
+  SurfaceIdAllocator* allocator_;
+
+  DISALLOW_COPY_AND_ASSIGN(SurfaceDisplayOutputSurface);
+};
+
+}  // namespace cc
+
+#endif  // CC_SURFACES_SURFACE_DISPLAY_OUTPUT_SURFACE_H_

content/browser/BUILD.gn

@@ -390,12 +390,6 @@ source_set("browser") {
     ]
   }
 
-  if (use_aura || is_mac || is_android) {
-    sources += rebase_path(
-            content_browser_gypi_values.compositor_browser_surface_sources,
-            ".",
-            "//content")
-  }
   if (use_aura || is_mac) {
     sources +=
         rebase_path(content_browser_gypi_values.compositor_browser_sources,

content/browser/compositor/gpu_process_transport_factory.cc

@@ -14,15 +14,15 @@
 #include "base/threading/thread.h"
 #include "cc/output/compositor_frame.h"
 #include "cc/output/output_surface.h"
+#include "cc/surfaces/onscreen_display_client.h"
+#include "cc/surfaces/surface_display_output_surface.h"
 #include "cc/surfaces/surface_manager.h"
 #include "content/browser/compositor/browser_compositor_output_surface.h"
 #include "content/browser/compositor/browser_compositor_output_surface_proxy.h"
 #include "content/browser/compositor/gpu_browser_compositor_output_surface.h"
 #include "content/browser/compositor/gpu_surfaceless_browser_compositor_output_surface.h"
-#include "content/browser/compositor/onscreen_display_client.h"
 #include "content/browser/compositor/reflector_impl.h"
 #include "content/browser/compositor/software_browser_compositor_output_surface.h"
-#include "content/browser/compositor/surface_display_output_surface.h"
 #include "content/browser/gpu/browser_gpu_channel_host_factory.h"
 #include "content/browser/gpu/browser_gpu_memory_buffer_manager.h"
 #include "content/browser/gpu/compositor_util.h"
@@ -66,7 +66,7 @@ namespace content {
 struct GpuProcessTransportFactory::PerCompositorData {
   int surface_id;
   scoped_refptr<ReflectorImpl> reflector;
-  scoped_ptr<OnscreenDisplayClient> display_client;
+  scoped_ptr<cc::OnscreenDisplayClient> display_client;
 };
 
 GpuProcessTransportFactory::GpuProcessTransportFactory()
@@ -229,12 +229,14 @@ void GpuProcessTransportFactory::EstablishedGpuChannel(
           compositor->vsync_manager(),
           CreateOverlayCandidateValidator(compositor->widget())));
     }
-    scoped_ptr<OnscreenDisplayClient> display_client(new OnscreenDisplayClient(
-        display_surface.Pass(), manager, compositor->GetRendererSettings(),
-        compositor->task_runner()));
+    scoped_ptr<cc::OnscreenDisplayClient> display_client(
+        new cc::OnscreenDisplayClient(
+            display_surface.Pass(), manager, HostSharedBitmapManager::current(),
+            BrowserGpuMemoryBufferManager::current(),
+            compositor->GetRendererSettings(), compositor->task_runner()));
 
-    scoped_ptr<SurfaceDisplayOutputSurface> output_surface(
-        new SurfaceDisplayOutputSurface(
+    scoped_ptr<cc::SurfaceDisplayOutputSurface> output_surface(
+        new cc::SurfaceDisplayOutputSurface(
             manager, compositor->surface_id_allocator(), context_provider));
     display_client->set_surface_output_surface(output_surface.get());
     output_surface->set_display_client(display_client.get());

content/browser/compositor/surface_display_output_surface.h

@@ -1,64 +0,0 @@
-// Copyright 2014 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_BROWSER_COMPOSITOR_SURFACE_DISPLAY_OUTPUT_SURFACE_H_
-#define CONTENT_BROWSER_COMPOSITOR_SURFACE_DISPLAY_OUTPUT_SURFACE_H_
-
-#include "cc/output/output_surface.h"
-#include "cc/surfaces/surface_factory.h"
-#include "cc/surfaces/surface_factory_client.h"
-#include "cc/surfaces/surface_id_allocator.h"
-
-namespace cc {
-class Display;
-class SurfaceManager;
-}
-
-namespace content {
-class OnscreenDisplayClient;
-
-// This class is maps a compositor OutputSurface to the surface system's Display
-// concept, allowing a compositor client to submit frames for a native root
-// window or physical display.
-class SurfaceDisplayOutputSurface : public cc::OutputSurface,
-                                    public cc::SurfaceFactoryClient {
- public:
-  // The underlying cc::Display and cc::SurfaceManager must outlive this class.
-  SurfaceDisplayOutputSurface(
-      cc::SurfaceManager* surface_manager,
-      cc::SurfaceIdAllocator* allocator,
-      const scoped_refptr<cc::ContextProvider>& context_provider);
-  ~SurfaceDisplayOutputSurface() override;
-
-  void set_display_client(OnscreenDisplayClient* display_client) {
-    display_client_ = display_client;
-  }
-  cc::SurfaceFactory* factory() { return &factory_; }
-  void ReceivedVSyncParameters(base::TimeTicks timebase,
-                               base::TimeDelta interval);
-
-  // cc::OutputSurface implementation.
-  void SwapBuffers(cc::CompositorFrame* frame) override;
-  bool BindToClient(cc::OutputSurfaceClient* client) override;
-  void ForceReclaimResources() override;
-
-  // cc::SurfaceFactoryClient implementation.
-  void ReturnResources(const cc::ReturnedResourceArray& resources) override;
-
- private:
-  void SwapBuffersComplete(cc::SurfaceDrawStatus drawn);
-
-  OnscreenDisplayClient* display_client_;
-  cc::SurfaceManager* surface_manager_;
-  cc::SurfaceFactory factory_;
-  gfx::Size display_size_;
-  cc::SurfaceId surface_id_;
-  cc::SurfaceIdAllocator* allocator_;
-
-  DISALLOW_COPY_AND_ASSIGN(SurfaceDisplayOutputSurface);
-};
-
-}  // namespace content
-
-#endif  // CONTENT_BROWSER_COMPOSITOR_SURFACE_DISPLAY_OUTPUT_SURFACE_H_

content/browser/compositor/test/no_transport_image_transport_factory.cc

@@ -6,6 +6,7 @@
 
 #include "cc/output/context_provider.h"
 #include "cc/surfaces/surface_manager.h"
+#include "content/browser/gpu/compositor_util.h"
 #include "content/common/gpu/client/gl_helper.h"
 #include "gpu/command_buffer/client/gles2_interface.h"
 #include "ui/compositor/compositor.h"
@@ -14,10 +15,11 @@
 namespace content {
 
 NoTransportImageTransportFactory::NoTransportImageTransportFactory()
-    // The context factory created here is for unit tests, thus passing in true
-    // in constructor.
-    : context_factory_(new ui::InProcessContextFactory(true)),
-      surface_manager_(new cc::SurfaceManager) {
+    : surface_manager_(UseSurfacesEnabled() ? new cc::SurfaceManager : nullptr),
+      // The context factory created here is for unit tests, thus passing in
+      // true in constructor.
+      context_factory_(
+          new ui::InProcessContextFactory(true, surface_manager_.get())) {
 }
 
 NoTransportImageTransportFactory::~NoTransportImageTransportFactory() {

content/browser/compositor/test/no_transport_image_transport_factory.h

@@ -35,10 +35,10 @@ class NoTransportImageTransportFactory : public ImageTransportFactory {
 #endif
 
  private:
+  scoped_ptr<cc::SurfaceManager> surface_manager_;
   scoped_ptr<ui::ContextFactory> context_factory_;
   scoped_refptr<cc::ContextProvider> context_provider_;
   scoped_ptr<GLHelper> gl_helper_;
-  scoped_ptr<cc::SurfaceManager> surface_manager_;
   ObserverList<ImageTransportFactoryObserver> observer_list_;
 
   DISALLOW_COPY_AND_ASSIGN(NoTransportImageTransportFactory);

content/browser/renderer_host/compositor_impl_android.cc

@@ -28,12 +28,12 @@
 #include "cc/output/output_surface.h"
 #include "cc/output/output_surface_client.h"
 #include "cc/scheduler/begin_frame_source.h"
+#include "cc/surfaces/onscreen_display_client.h"
+#include "cc/surfaces/surface_display_output_surface.h"
 #include "cc/surfaces/surface_id_allocator.h"
 #include "cc/surfaces/surface_manager.h"
 #include "cc/trees/layer_tree_host.h"
 #include "content/browser/android/child_process_launcher_android.h"
-#include "content/browser/compositor/onscreen_display_client.h"
-#include "content/browser/compositor/surface_display_output_surface.h"
 #include "content/browser/gpu/browser_gpu_channel_host_factory.h"
 #include "content/browser/gpu/browser_gpu_memory_buffer_manager.h"
 #include "content/browser/gpu/compositor_util.h"
@@ -591,13 +591,14 @@ void CompositorImpl::CreateOutputSurface() {
 
   cc::SurfaceManager* manager = GetSurfaceManager();
   if (manager) {
-    display_client_.reset(
-        new OnscreenDisplayClient(real_output_surface.Pass(), manager,
+    display_client_.reset(new cc::OnscreenDisplayClient(
+        real_output_surface.Pass(), manager, HostSharedBitmapManager::current(),
+        BrowserGpuMemoryBufferManager::current(),
         host_->settings().renderer_settings,
         base::MessageLoopProxy::current()));
-    scoped_ptr<SurfaceDisplayOutputSurface> surface_output_surface(
-        new SurfaceDisplayOutputSurface(manager, surface_id_allocator_.get(),
-                                        context_provider));
+    scoped_ptr<cc::SurfaceDisplayOutputSurface> surface_output_surface(
+        new cc::SurfaceDisplayOutputSurface(
+            manager, surface_id_allocator_.get(), context_provider));
 
     display_client_->set_surface_output_surface(surface_output_surface.get());
     surface_output_surface->set_display_client(display_client_.get());

content/browser/renderer_host/compositor_impl_android.h

@@ -27,12 +27,12 @@ struct ANativeWindow;
 namespace cc {
 class Layer;
 class LayerTreeHost;
+class OnscreenDisplayClient;
 class SurfaceIdAllocator;
 }
 
 namespace content {
 class CompositorClient;
-class OnscreenDisplayClient;
 
 // -----------------------------------------------------------------------------
 // Browser-side compositor that manages a tree of content and UI layers.
@@ -144,7 +144,7 @@ class CONTENT_EXPORT CompositorImpl
   ui::UIResourceProvider ui_resource_provider_;
   ui::ResourceManagerImpl resource_manager_;
 
-  scoped_ptr<OnscreenDisplayClient> display_client_;
+  scoped_ptr<cc::OnscreenDisplayClient> display_client_;
   scoped_ptr<cc::SurfaceIdAllocator> surface_id_allocator_;
 
   gfx::Size size_;

content/content_browser.gypi

@@ -1537,12 +1537,6 @@
       'browser/context_factory.cc',
       'browser/memory_pressure_observer.cc',
     ],
-    'compositor_browser_surface_sources': [
-      'browser/compositor/onscreen_display_client.cc',
-      'browser/compositor/onscreen_display_client.h',
-      'browser/compositor/surface_display_output_surface.cc',
-      'browser/compositor/surface_display_output_surface.h',
-    ],
     'plugin_browser_sources': [
       'browser/pepper_flash_settings_helper_impl.cc',
       'browser/pepper_flash_settings_helper_impl.h',
@@ -1720,9 +1714,6 @@
         '../sandbox/sandbox.gyp:sandbox',
       ],
     }],
-    ['OS!="ios"', {
-      'sources': [ '<@(compositor_browser_surface_sources)' ],
-    }],
     ['OS!="android" and OS!="ios"', {
       'dependencies': [
         'browser/tracing/tracing_resources.gyp:tracing_resources',

ui/aura/bench/bench_main.cc

@@ -302,7 +302,7 @@ int main(int argc, char** argv) {
   // The ContextFactory must exist before any Compositors are created.
   bool context_factory_for_test = false;
   scoped_ptr<ui::InProcessContextFactory> context_factory(
-      new ui::InProcessContextFactory(context_factory_for_test));
+      new ui::InProcessContextFactory(context_factory_for_test, nullptr));
 
   base::i18n::InitializeICU();
 

ui/aura/demo/demo_main.cc

@@ -120,7 +120,7 @@ int DemoMain() {
   // The ContextFactory must exist before any Compositors are created.
   bool context_factory_for_test = false;
   scoped_ptr<ui::InProcessContextFactory> context_factory(
-      new ui::InProcessContextFactory(context_factory_for_test));
+      new ui::InProcessContextFactory(context_factory_for_test, nullptr));
   context_factory->set_use_test_surface(false);
 
   // Create the message-loop here before creating the root window.

ui/compositor/test/context_factories_for_test.cc

@@ -30,7 +30,8 @@ ui::ContextFactory* InitializeContextFactoryForTests(bool enable_pixel_output) {
   if (enable_pixel_output)
     g_disable_null_draw = new gfx::DisableNullDrawGLBindings;
   bool context_factory_for_test = true;
-  g_implicit_factory = new InProcessContextFactory(context_factory_for_test);
+  g_implicit_factory =
+      new InProcessContextFactory(context_factory_for_test, nullptr);
   return g_implicit_factory;
 }
 

ui/compositor/test/in_process_context_factory.cc

@@ -10,6 +10,8 @@
 #include "cc/output/compositor_frame.h"
 #include "cc/output/context_provider.h"
 #include "cc/output/output_surface_client.h"
+#include "cc/surfaces/onscreen_display_client.h"
+#include "cc/surfaces/surface_display_output_surface.h"
 #include "cc/surfaces/surface_id_allocator.h"
 #include "cc/test/pixel_test_output_surface.h"
 #include "cc/test/test_shared_bitmap_manager.h"
@@ -62,10 +64,13 @@ class DirectOutputSurface : public cc::OutputSurface {
 
 }  // namespace
 
-InProcessContextFactory::InProcessContextFactory(bool context_factory_for_test)
+InProcessContextFactory::InProcessContextFactory(
+    bool context_factory_for_test,
+    cc::SurfaceManager* surface_manager)
     : next_surface_id_namespace_(1u),
       use_test_surface_(true),
-      context_factory_for_test_(context_factory_for_test) {
+      context_factory_for_test_(context_factory_for_test),
+      surface_manager_(surface_manager) {
   DCHECK_NE(gfx::GetGLImplementation(), gfx::kGLImplementationNone)
       << "If running tests, ensure that main() is calling "
       << "gfx::GLSurface::InitializeOneOffForTests()";
@@ -82,7 +87,9 @@ InProcessContextFactory::InProcessContextFactory(bool context_factory_for_test)
   }
 }
 
-InProcessContextFactory::~InProcessContextFactory() {}
+InProcessContextFactory::~InProcessContextFactory() {
+  DCHECK(per_compositor_data_.empty());
+}
 
 void InProcessContextFactory::CreateOutputSurface(
     base::WeakPtr<Compositor> compositor,
@@ -105,13 +112,36 @@ void InProcessContextFactory::CreateOutputSurface(
       InProcessContextProvider::Create(attribs, lose_context_when_out_of_memory,
                                        compositor->widget(), "UICompositor");
 
+  scoped_ptr<cc::OutputSurface> real_output_surface;
+
   if (use_test_surface_) {
     bool flipped_output_surface = false;
-    compositor->SetOutputSurface(make_scoped_ptr(new cc::PixelTestOutputSurface(
-        context_provider, flipped_output_surface)));
+    real_output_surface = make_scoped_ptr(new cc::PixelTestOutputSurface(
+        context_provider, flipped_output_surface));
   } else {
-    compositor->SetOutputSurface(
-        make_scoped_ptr(new DirectOutputSurface(context_provider)));
+    real_output_surface =
+        make_scoped_ptr(new DirectOutputSurface(context_provider));
+  }
+
+  if (surface_manager_) {
+    scoped_ptr<cc::OnscreenDisplayClient> display_client(
+        new cc::OnscreenDisplayClient(
+            real_output_surface.Pass(), surface_manager_,
+            GetSharedBitmapManager(), GetGpuMemoryBufferManager(),
+            compositor->GetRendererSettings(), compositor->task_runner()));
+    scoped_ptr<cc::SurfaceDisplayOutputSurface> surface_output_surface(
+        new cc::SurfaceDisplayOutputSurface(surface_manager_,
+                                            compositor->surface_id_allocator(),
+                                            context_provider));
+    display_client->set_surface_output_surface(surface_output_surface.get());
+    surface_output_surface->set_display_client(display_client.get());
+
+    compositor->SetOutputSurface(surface_output_surface.Pass());
+
+    delete per_compositor_data_[compositor.get()];
+    per_compositor_data_[compositor.get()] = display_client.release();
+  } else {
+    compositor->SetOutputSurface(real_output_surface.Pass());
   }
 }
 
@@ -140,7 +170,12 @@ InProcessContextFactory::SharedMainThreadContextProvider() {
   return shared_main_thread_contexts_;
 }
 
-void InProcessContextFactory::RemoveCompositor(Compositor* compositor) {}
+void InProcessContextFactory::RemoveCompositor(Compositor* compositor) {
+  if (!per_compositor_data_.count(compositor))
+    return;
+  delete per_compositor_data_[compositor];
+  per_compositor_data_.erase(compositor);
+}
 
 bool InProcessContextFactory::DoesCreateTestContexts() {
   return context_factory_for_test_;
@@ -169,6 +204,9 @@ InProcessContextFactory::CreateSurfaceIdAllocator() {
 
 void InProcessContextFactory::ResizeDisplay(ui::Compositor* compositor,
                                             const gfx::Size& size) {
+  if (!per_compositor_data_.count(compositor))
+    return;
+  per_compositor_data_[compositor]->display()->Resize(size);
 }
 
 }  // namespace ui

ui/compositor/test/in_process_context_factory.h

@@ -13,11 +13,19 @@ namespace base {
 class Thread;
 }
 
+namespace cc {
+class OnscreenDisplayClient;
+class SurfaceManager;
+}
+
 namespace ui {
 
 class InProcessContextFactory : public ContextFactory {
  public:
-  explicit InProcessContextFactory(bool context_factory_for_test);
+  // surface_manager is owned by the creator of this and must outlive the
+  // context factory.
+  InProcessContextFactory(bool context_factory_for_test,
+                          cc::SurfaceManager* surface_manager);
   ~InProcessContextFactory() override;
 
   // If true (the default) an OutputSurface is created that does not display
@@ -51,8 +59,10 @@ class InProcessContextFactory : public ContextFactory {
   cc::TestGpuMemoryBufferManager gpu_memory_buffer_manager_;
   uint32_t next_surface_id_namespace_;
   bool use_test_surface_;
+  bool context_factory_for_test_;
+  cc::SurfaceManager* surface_manager_;
 
-  const bool context_factory_for_test_;
+  base::hash_map<Compositor*, cc::OnscreenDisplayClient*> per_compositor_data_;
 
   DISALLOW_COPY_AND_ASSIGN(InProcessContextFactory);
 };

ui/views/examples/examples_main.cc

@@ -57,7 +57,7 @@ int main(int argc, char** argv) {
   // The ContextFactory must exist before any Compositors are created.
   bool context_factory_for_test = false;
   scoped_ptr<ui::InProcessContextFactory> context_factory(
-      new ui::InProcessContextFactory(context_factory_for_test));
+      new ui::InProcessContextFactory(context_factory_for_test, nullptr));
   context_factory->set_use_test_surface(false);
 
   base::MessageLoopForUI message_loop;