blimp: Move BlimpCompositor to use delegated rendering.

blimp/client/app/compositor/browser_compositor.cc

+// Copyright 2016 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 "blimp/client/app/compositor/browser_compositor.h"
+
+#include "base/lazy_instance.h"
+#include "base/threading/thread_task_runner_handle.h"
+#include "blimp/client/feature/compositor/blimp_context_provider.h"
+#include "blimp/client/feature/compositor/blimp_gpu_memory_buffer_manager.h"
+#include "cc/animation/animation_host.h"
+#include "cc/layers/layer.h"
+#include "cc/output/compositor_frame.h"
+#include "cc/output/texture_mailbox_deleter.h"
+#include "cc/raster/single_thread_task_graph_runner.h"
+#include "cc/surfaces/display.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 "gpu/command_buffer/client/context_support.h"
+
+namespace blimp {
+namespace client {
+
+namespace {
+
+class SimpleTaskGraphRunner : public cc::SingleThreadTaskGraphRunner {
+ public:
+  SimpleTaskGraphRunner() {
+    Start("BlimpBrowserCompositorWorker",
+          base::SimpleThread::Options(base::ThreadPriority::BACKGROUND));
+  }
+
+  ~SimpleTaskGraphRunner() override { Shutdown(); }
+};
+
+class DisplayOutputSurface : public cc::OutputSurface {
+ public:
+  explicit DisplayOutputSurface(
+      scoped_refptr<cc::ContextProvider> context_provider)
+      : cc::OutputSurface(std::move(context_provider), nullptr, nullptr) {}
+
+  ~DisplayOutputSurface() override {}
+
+  // cc::OutputSurface implementation
+  void SwapBuffers(cc::CompositorFrame frame) override {
+    // See cc::OutputSurface::SwapBuffers() comment for details.
+    context_provider_->ContextSupport()->Swap();
+    cc::OutputSurface::PostSwapBuffersComplete();
+  }
+
+  uint32_t GetFramebufferCopyTextureFormat() override {
+    auto* gl = static_cast<BlimpContextProvider*>(context_provider());
+    return gl->GetCopyTextureInternalFormat();
+  }
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(DisplayOutputSurface);
+};
+
+base::LazyInstance<SimpleTaskGraphRunner> g_task_graph_runner =
+    LAZY_INSTANCE_INITIALIZER;
+
+base::LazyInstance<cc::SurfaceManager> g_surface_manager =
+    LAZY_INSTANCE_INITIALIZER;
+
+base::LazyInstance<BlimpGpuMemoryBufferManager> g_gpu_memory_buffer_manager =
+    LAZY_INSTANCE_INITIALIZER;
+
+uint32_t g_surface_id = 0;
+
+}  // namespace
+
+// static
+cc::SurfaceManager* BrowserCompositor::GetSurfaceManager() {
+  return g_surface_manager.Pointer();
+}
+
+// static
+BlimpGpuMemoryBufferManager* BrowserCompositor::GetGpuMemoryBufferManager() {
+  return g_gpu_memory_buffer_manager.Pointer();
+}
+
+// static
+uint32_t BrowserCompositor::AllocateSurfaceClientId() {
+  return ++g_surface_id;
+}
+
+BrowserCompositor::BrowserCompositor()
+    : surface_id_allocator_(base::MakeUnique<cc::SurfaceIdAllocator>(
+          BrowserCompositor::AllocateSurfaceClientId())),
+      widget_(gfx::kNullAcceleratedWidget),
+      output_surface_request_pending_(false),
+      root_layer_(cc::Layer::Create()) {
+  BrowserCompositor::GetSurfaceManager()->RegisterSurfaceClientId(
+      surface_id_allocator_->client_id());
+
+  cc::LayerTreeHost::InitParams params;
+  params.client = this;
+  params.gpu_memory_buffer_manager =
+      BrowserCompositor::GetGpuMemoryBufferManager();
+  params.task_graph_runner = g_task_graph_runner.Pointer();
+  cc::LayerTreeSettings settings;
+  params.settings = &settings;
+  params.main_task_runner = base::ThreadTaskRunnerHandle::Get();
+  params.animation_host = cc::AnimationHost::CreateMainInstance();
+  host_ = cc::LayerTreeHost::CreateSingleThreaded(this, &params);
+
+  root_layer_->SetBackgroundColor(SK_ColorWHITE);
+  host_->GetLayerTree()->SetRootLayer(root_layer_);
+  host_->set_surface_client_id(surface_id_allocator_->client_id());
+}
+
+BrowserCompositor::~BrowserCompositor() {
+  root_layer_->RemoveAllChildren();

[David Trainor- moved to gerrit, 2016/08/22 23:58:10]

Is all of this teardown needed?

[Khushal, 2016/08/23 02:53:11]

Actually no. We have the SetSurface cleanup in Clank, but I think that's to
remove the reference from the GpuSurfaceTracker, which we don't need. Thank for
pointing this out, we do need to clean up the reference with the SurfaceManager,
added that.

+  host_->GetLayerTree()->SetRootLayer(nullptr);
+  root_layer_ = nullptr;
+  SetAcceleratedWidget(gfx::kNullAcceleratedWidget);
+}
+
+void BrowserCompositor::SetContentLayer(
+    scoped_refptr<cc::Layer> content_layer) {
+  root_layer_->RemoveAllChildren();
+  root_layer_->AddChild(content_layer);
+}
+
+void BrowserCompositor::SetSize(const gfx::Size& size_in_px) {
+  viewport_size_in_px_ = size_in_px;
+  // Update the host.

[David Trainor- moved to gerrit, 2016/08/22 23:58:10]

newline before this

[Khushal, 2016/08/23 02:53:11]

Done.

+  host_->GetLayerTree()->SetViewportSize(viewport_size_in_px_);
+  root_layer_->SetBounds(viewport_size_in_px_);
+
+  // Update the display.
+  if (display_) {
+    display_->Resize(viewport_size_in_px_);
+  }
+}
+
+void BrowserCompositor::SetAcceleratedWidget(gfx::AcceleratedWidget widget) {
+  // Kill all references to the old widget.
+  if (widget_ != gfx::kNullAcceleratedWidget) {
+    // We are always visible if we have a widget.
+    DCHECK(host_->visible());
+    host_->SetVisible(false);
+    if (!host_->output_surface_lost()) {
+      host_->ReleaseOutputSurface();
+    }
+    display_.reset();
+  }
+
+  widget_ = gfx::kNullAcceleratedWidget;
+
+  if (widget != gfx::kNullAcceleratedWidget) {
+    widget_ = widget;
+    host_->SetVisible(true);
+    if (output_surface_request_pending_)
+      HandlePendingOutputSurfaceRequest();
+  }
+}
+
+void BrowserCompositor::RequestNewOutputSurface() {
+  DCHECK(!output_surface_request_pending_)
+      << "We already have a pending request?";
+  output_surface_request_pending_ = true;
+  HandlePendingOutputSurfaceRequest();
+}
+
+void BrowserCompositor::DidInitializeOutputSurface() {
+  output_surface_request_pending_ = false;
+}
+
+void BrowserCompositor::DidFailToInitializeOutputSurface() {
+  NOTREACHED() << "Can't fail to initialize the OutputSurface here";
+}
+
+void BrowserCompositor::DidCompleteSwapBuffers() {
+  if (!did_complete_swap_buffers_.is_null()) {
+    did_complete_swap_buffers_.Run();
+  }
+}
+
+void BrowserCompositor::HandlePendingOutputSurfaceRequest() {
+  DCHECK(output_surface_request_pending_);
+
+  // Can't handle the request right now since we don't have a widget.
+  if (!host_->visible())
+    return;
+
+  DCHECK_NE(gfx::kNullAcceleratedWidget, widget_);
+
+  scoped_refptr<cc::ContextProvider> context_provider =
+      BlimpContextProvider::Create(
+          widget_, BrowserCompositor::GetGpuMemoryBufferManager());
+
+  std::unique_ptr<cc::OutputSurface> display_output_surface =
+      base::MakeUnique<DisplayOutputSurface>(context_provider);
+
+  auto* task_runner = base::ThreadTaskRunnerHandle::Get().get();
+  std::unique_ptr<cc::SyntheticBeginFrameSource> begin_frame_source(
+      new cc::DelayBasedBeginFrameSource(
+          base::MakeUnique<cc::DelayBasedTimeSource>(task_runner)));
+  std::unique_ptr<cc::DisplayScheduler> scheduler(new cc::DisplayScheduler(
+      begin_frame_source.get(), task_runner,
+      display_output_surface->capabilities().max_frames_pending));
+
+  display_ = base::MakeUnique<cc::Display>(
+      nullptr /*shared_bitmap_manager*/,
+      BrowserCompositor::GetGpuMemoryBufferManager(),
+      host_->settings().renderer_settings, std::move(begin_frame_source),
+      std::move(display_output_surface), std::move(scheduler),
+      base::MakeUnique<cc::TextureMailboxDeleter>(task_runner));
+  display_->SetVisible(true);
+  display_->Resize(viewport_size_in_px_);
+
+  // The Browser compositor and display share the same context provider.
+  std::unique_ptr<cc::OutputSurface> delegated_output_surface =
+      base::MakeUnique<cc::SurfaceDisplayOutputSurface>(
+          BrowserCompositor::GetSurfaceManager(), surface_id_allocator_.get(),
+          display_.get(), context_provider, nullptr);
+
+  host_->SetOutputSurface(std::move(delegated_output_surface));
+}
+
+}  // namespace client
+}  // namespace blimp