SurfacelessSurfaces for Mus

components/mus/surfaces/top_level_display_client.cc

 // Copyright 2015 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 "components/mus/surfaces/top_level_display_client.h"
 
 #include "base/thread_task_runner_handle.h"
 #include "cc/output/compositor_frame.h"
 #include "cc/output/copy_output_request.h"
 #include "cc/scheduler/begin_frame_source.h"
 #include "cc/surfaces/display.h"
 #include "cc/surfaces/display_scheduler.h"
 #include "cc/surfaces/surface.h"
 #include "components/mus/gles2/gpu_state.h"
 #include "components/mus/surfaces/direct_output_surface.h"
 #include "components/mus/surfaces/surfaces_context_provider.h"
 #include "components/mus/surfaces/surfaces_state.h"
+#include "ui/compositor/compositor_vsync_manager.h"

[Fady Samuel, 2016/04/12 02:54:41]

Do we want this dependency on ui/compositor from mus?

[rjkroege, 2016/04/12 19:27:54]

no. I removed all of the actual dependency code. This was an oversight. Done

+
+#if defined(USE_OZONE)
+#include "components/mus/surfaces/direct_output_surface_ozone.h"
+#include "gpu/command_buffer/client/gles2_interface.h"
+#endif
 
 namespace base {
 class SingleThreadTaskRunner;
 }
 
 namespace mus {
 namespace {
 void CallCallback(const base::Closure& callback, cc::SurfaceDrawStatus status) {
   callback.Run();
 }
 }
 
 TopLevelDisplayClient::TopLevelDisplayClient(
     gfx::AcceleratedWidget widget,
     const scoped_refptr<GpuState>& gpu_state,
     const scoped_refptr<SurfacesState>& surfaces_state)
     : task_runner_(base::ThreadTaskRunnerHandle::Get()),
       surfaces_state_(surfaces_state),
       factory_(surfaces_state->manager(), this),
       cc_id_(static_cast<uint64_t>(surfaces_state->next_id_namespace()) << 32) {
   factory_.Create(cc_id_);
 
   display_.reset(new cc::Display(this, surfaces_state_->manager(), nullptr,
                                  nullptr, cc::RendererSettings()));
 
-  scoped_ptr<cc::OutputSurface> output_surface =
-      make_scoped_ptr(new DirectOutputSurface(
-          new SurfacesContextProvider(this, widget, gpu_state)));
+  scoped_refptr<SurfacesContextProvider> scp(

[Fady Samuel, 2016/04/12 02:54:41]

nit: better variable name please.

[rjkroege, 2016/04/12 19:27:54]

Done.

+      new SurfacesContextProvider(this, widget, gpu_state));
+  // TODO(rjkroege): If there is something better to do than CHECK, add it.
+  CHECK(scp->BindToCurrentThread());
+
+  scoped_ptr<cc::OutputSurface> output_surface;
+  if (scp->ContextCapabilities().gpu.surfaceless) {
+#if defined(USE_OZONE)
+    output_surface = make_scoped_ptr(
+        new DirectOutputSurfaceOzone(scp, widget, GL_TEXTURE_2D, GL_RGB));
+#else
+    NOTREACHED();
+#endif
+  } else {
+    output_surface = make_scoped_ptr(new DirectOutputSurface(scp));
+  }
 
   int max_frames_pending = output_surface->capabilities().max_frames_pending;
   DCHECK_GT(max_frames_pending, 0);
 
   synthetic_frame_source_.reset(new cc::SyntheticBeginFrameSource(
       task_runner_.get(), cc::BeginFrameArgs::DefaultInterval()));
 
   scheduler_.reset(
       new cc::DisplayScheduler(display_.get(), synthetic_frame_source_.get(),
                                task_runner_.get(), max_frames_pending));
@@ skipping 61 matching lines @@
     const cc::ReturnedResourceArray& resources) {
   // TODO(fsamuel): Implement this.
 }
 
 void TopLevelDisplayClient::SetBeginFrameSource(
     cc::BeginFrameSource* begin_frame_source) {
   // TODO(tansell): Implement this.
 }
 
 }  // namespace mus