mus+ash: Enable Chrome HW rendering in mus+ash

cc/surfaces/display.cc

 // 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.
 
 #include "cc/surfaces/display.h"
 
 #include <stddef.h>
 
 #include "base/memory/ptr_util.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "base/trace_event/trace_event.h"
 #include "cc/debug/benchmark_instrumentation.h"
 #include "cc/output/compositor_frame.h"
 #include "cc/output/compositor_frame_ack.h"
+#include "cc/output/delegating_renderer.h"
 #include "cc/output/direct_renderer.h"
 #include "cc/output/gl_renderer.h"
 #include "cc/output/renderer_settings.h"
 #include "cc/output/software_renderer.h"
 #include "cc/output/texture_mailbox_deleter.h"
 #include "cc/scheduler/begin_frame_source.h"
 #include "cc/surfaces/display_client.h"
 #include "cc/surfaces/display_scheduler.h"
 #include "cc/surfaces/surface.h"
 #include "cc/surfaces/surface_aggregator.h"
@@ skipping 126 matching lines @@
 
   std::unique_ptr<ResourceProvider> resource_provider(new ResourceProvider(
       output_surface_->context_provider(), bitmap_manager_,
       gpu_memory_buffer_manager_, nullptr, settings_.highp_threshold_min,
       settings_.texture_id_allocation_chunk_size,
       output_surface_->capabilities().delegated_sync_points_required,
       settings_.use_gpu_memory_buffer_resources,
       std::vector<unsigned>(static_cast<size_t>(gfx::BufferFormat::LAST) + 1,
                             GL_TEXTURE_2D)));
 
-  if (output_surface_->context_provider()) {
+  if (output_surface_->context_provider() &&
+      !output_surface_->capabilities().delegated_rendering) {
     std::unique_ptr<GLRenderer> renderer = GLRenderer::Create(
         this, &settings_, output_surface_.get(), resource_provider.get(),
         texture_mailbox_deleter_.get(), settings_.highp_threshold_min);
     if (!renderer)
       return;
     renderer_ = std::move(renderer);
+  } else if (output_surface_->context_provider() &&
+             output_surface_->capabilities().delegated_rendering) {
+    std::unique_ptr<DelegatingRenderer> renderer = DelegatingRenderer::Create(

[danakj, 2016/06/27 18:48:39]

I don't understand this, and am trying to do the opposite in other parts of the
code. Why would a Display do delegated rendering?

[danakj, 2016/06/27 18:57:28]

re: offline explanation.

I don't think there should be a Display on the delegating side. There should
just be a LayerTreeHostImpl sending frames to mus like in the renderer process.

So there should be no BrowserCompositorOutputSurface at all, instead there can
be a mus output surface like we have in the renderer, that is given to the
ui::Compositor instead of the SurfaceDisplayOutputSurface.

The outcome I'm expecting from mus is to have the browser process look more like
the renderer.

+        this, &settings_, output_surface_.get(), resource_provider.get());
+    if (!renderer)
+      return;
+    renderer_ = std::move(renderer);
+
   } else if (output_surface_->vulkan_context_provider()) {
 #if defined(ENABLE_VULKAN)
     std::unique_ptr<VulkanRenderer> renderer = VulkanRenderer::Create(
         this, &settings_, output_surface_.get(), resource_provider.get(),
         texture_mailbox_deleter_.get(), settings_.highp_threshold_min);
     if (!renderer)
       return;
     renderer_ = std::move(renderer);
 #else
     NOTREACHED();
 #endif
   } else {
     std::unique_ptr<SoftwareRenderer> renderer = SoftwareRenderer::Create(
         this, &settings_, output_surface_.get(), resource_provider.get(),
         true /* use_image_hijack_canvas */);
     if (!renderer)
       return;
     renderer_ = std::move(renderer);
   }
+  resource_provider_ = std::move(resource_provider);
 
-  renderer_->SetEnlargePassTextureAmount(enlarge_texture_amount_);
-
-  resource_provider_ = std::move(resource_provider);
-  // TODO(jbauman): Outputting an incomplete quad list doesn't work when using
-  // overlays.
-  bool output_partial_list = renderer_->Capabilities().using_partial_swap &&
-                             !output_surface_->GetOverlayCandidateValidator();
+  bool output_partial_list = false;
+  if (renderer_) {
+    if (!output_surface_->capabilities().delegated_rendering) {
+      static_cast<DirectRenderer*>(renderer_.get())
+          ->SetEnlargePassTextureAmount(enlarge_texture_amount_);
+    }
+    // TODO(jbauman): Outputting an incomplete quad list doesn't work when using
+    // overlays.
+    output_partial_list = renderer_->Capabilities().using_partial_swap &&
+                          !output_surface_->GetOverlayCandidateValidator();
+  }
   aggregator_.reset(new SurfaceAggregator(
       surface_manager_, resource_provider_.get(), output_partial_list));
   aggregator_->set_output_is_secure(output_is_secure_);
 }
 
 void Display::DidLoseOutputSurface() {
   if (scheduler_)
     scheduler_->OutputSurfaceLost();
   // WARNING: The client may delete the Display in this method call. Do not
   // make any additional references to members after this call.
@@ skipping 118 matching lines @@
 }
 
 void Display::DidSwapBuffers() {
   if (scheduler_)
     scheduler_->DidSwapBuffers();
 }
 
 void Display::DidSwapBuffersComplete() {
   if (scheduler_)
     scheduler_->DidSwapBuffersComplete();
-  if (renderer_)
-    renderer_->SwapBuffersComplete();
+  if (renderer_ && !output_surface_->capabilities().delegated_rendering)
+    static_cast<DirectRenderer*>(renderer_.get())->SwapBuffersComplete();
 }
 
 void Display::CommitVSyncParameters(base::TimeTicks timebase,
                                     base::TimeDelta interval) {
   // Display uses a BeginFrameSource instead.
   NOTREACHED();
 }
 
 void Display::DidReceiveTextureInUseResponses(
     const gpu::TextureInUseResponses& responses) {
-  if (renderer_)
-    renderer_->DidReceiveTextureInUseResponses(responses);
+  if (renderer_ && !output_surface_->capabilities().delegated_rendering) {
+    static_cast<DirectRenderer*>(renderer_.get())
+        ->DidReceiveTextureInUseResponses(responses);
+  }
 }
 
 void Display::SetBeginFrameSource(BeginFrameSource* source) {
   // The BeginFrameSource is set from the constructor, it doesn't come
   // from the OutputSurface for the Display.
   NOTREACHED();
 }
 
 void Display::SetMemoryPolicy(const ManagedMemoryPolicy& policy) {
   client_->DisplaySetMemoryPolicy(policy);
 }
 
 void Display::OnDraw(const gfx::Transform& transform,
                      const gfx::Rect& viewport,
                      const gfx::Rect& clip,
                      bool resourceless_software_draw) {
   NOTREACHED();
 }
 
 void Display::SetNeedsRedrawRect(const gfx::Rect& damage_rect) {
   aggregator_->SetFullDamageForSurface(current_surface_id_);
   if (scheduler_)
     scheduler_->SurfaceDamaged(current_surface_id_);
 }
 
 void Display::ReclaimResources(const CompositorFrameAck* ack) {
-  NOTREACHED();
+  DCHECK(output_surface_->capabilities().delegated_rendering);
+  if (renderer_)
+    renderer_->ReceiveSwapBuffersAck(*ack);
 }
 
 void Display::SetExternalTilePriorityConstraints(
     const gfx::Rect& viewport_rect,
     const gfx::Transform& transform) {
   NOTREACHED();
 }
 
 void Display::SetTreeActivationCallback(const base::Closure& callback) {
   NOTREACHED();
@@ skipping 26 matching lines @@
 
   if (surface_id == current_surface_id_)
     UpdateRootSurfaceResourcesLocked();
 }
 
 SurfaceId Display::CurrentSurfaceId() {
   return current_surface_id_;
 }
 
 }  // namespace cc