Initial checkin of the new Mozart compositor.

services/gfx/compositor/backend/gpu_output.cc

Index: services/gfx/compositor/backend/gpu_output.cc
diff --git a/services/gfx/compositor/backend/gpu_output.cc b/services/gfx/compositor/backend/gpu_output.cc
new file mode 100644
index 0000000000000000000000000000000000000000..51cc444384dfe527c6ea703744492d47744646fd
--- /dev/null
+++ b/services/gfx/compositor/backend/gpu_output.cc
@@ -0,0 +1,109 @@
+// 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 "services/gfx/compositor/backend/gpu_output.h"
+
+#include "base/bind.h"
+#include "base/location.h"
+#include "base/logging.h"
+#include "base/message_loop/message_loop.h"
+#include "services/gfx/compositor/backend/gpu_rasterizer.h"
+
+namespace compositor {
+
+template <typename T>
+static void Drop(scoped_ptr<T> ptr) {}
+
+static scoped_ptr<base::MessagePump> CreateMessagePumpMojo() {
+  return base::MessageLoop::CreateMessagePumpForType(
+      base::MessageLoop::TYPE_DEFAULT);
+}
+
+GpuOutput::GpuOutput(mojo::ContextProviderPtr context_provider,
+                     const SchedulerCallbacks& scheduler_callbacks,
+                     const base::Closure& error_callback)
+    : frame_queue_(std::make_shared<FrameQueue>()),
+      scheduler_(std::make_shared<VsyncScheduler>(base::MessageLoop::current()
+                                                      ->task_runner(),
+                                                  scheduler_callbacks)),
+      rasterizer_delegate_(
+          make_scoped_ptr(new RasterizerDelegate(frame_queue_))) {
+  DCHECK(context_provider);
+
+  base::Thread::Options options;
+  options.message_pump_factory = base::Bind(&CreateMessagePumpMojo);
+
+  rasterizer_thread_.reset(new base::Thread("gpu_rasterizer"));
+  rasterizer_thread_->StartWithOptions(options);
+  rasterizer_task_runner_ = rasterizer_thread_->message_loop()->task_runner();
+
+  rasterizer_task_runner_->PostTask(
+      FROM_HERE,
+      base::Bind(&RasterizerDelegate::CreateRasterizer,
+                 base::Unretained(rasterizer_delegate_.get()),
+                 base::Passed(context_provider.PassInterface()), scheduler_,
+                 base::MessageLoop::current()->task_runner(), error_callback));
+}
+
+GpuOutput::~GpuOutput() {
+  // Ensure destruction happens on the correct thread.
+  rasterizer_task_runner_->PostTask(
+      FROM_HERE, base::Bind(&Drop<RasterizerDelegate>,
+                            base::Passed(&rasterizer_delegate_)));
+}
+
+Scheduler* GpuOutput::scheduler() {
+  return scheduler_.get();
+}
+
+void GpuOutput::SubmitFrame(const std::shared_ptr<RenderFrame>& frame) {
+  if (frame_queue_->PutFrame(frame)) {

[abarth, 2016/01/10 04:22:09]

We should talk in person about whether this scheduling model is what you
actually want.  Rather than dropping frames here, you might want to apply more
back pressure earlier in the pipeline.  Obviously, scheduling is a complicated
topic and one that we'll iterate on over time, so I wouldn't worry about it too
much for this iteration.

[jeffbrown, 2016/01/16 03:28:31]

Agreed.  This needs backpressure.  I'll fix that later.

+    rasterizer_task_runner_->PostTask(
+        FROM_HERE, base::Bind(&RasterizerDelegate::SubmitNextFrame,
+                              base::Unretained(rasterizer_delegate_.get())));
+  }
+}
+
+GpuOutput::FrameQueue::FrameQueue() {}
+
+GpuOutput::FrameQueue::~FrameQueue() {}
+
+bool GpuOutput::FrameQueue::PutFrame(
+    const std::shared_ptr<RenderFrame>& frame) {
+  std::lock_guard<std::mutex> lock(mutex_);
+  bool was_empty = !next_frame_.get();
+  next_frame_ = frame;
+  return was_empty;
+}
+
+std::shared_ptr<RenderFrame> GpuOutput::FrameQueue::TakeFrame() {
+  std::lock_guard<std::mutex> lock(mutex_);
+  return std::move(next_frame_);
+}
+
+GpuOutput::RasterizerDelegate::RasterizerDelegate(
+    const std::shared_ptr<FrameQueue>& frame_queue)
+    : frame_queue_(frame_queue) {
+  DCHECK(frame_queue_);
+}
+
+GpuOutput::RasterizerDelegate::~RasterizerDelegate() {}
+
+void GpuOutput::RasterizerDelegate::CreateRasterizer(
+    mojo::InterfacePtrInfo<mojo::ContextProvider> context_provider_info,
+    const std::shared_ptr<VsyncScheduler>& scheduler,
+    const scoped_refptr<base::TaskRunner>& task_runner,
+    const base::Closure& error_callback) {
+  rasterizer_.reset(
+      new GpuRasterizer(mojo::MakeProxy(context_provider_info.Pass()).Pass(),
+                        scheduler, task_runner, error_callback));
+}
+
+void GpuOutput::RasterizerDelegate::SubmitNextFrame() {
+  std::shared_ptr<RenderFrame> frame(frame_queue_->TakeFrame());
+  DCHECK(frame);
+  rasterizer_->SubmitFrame(frame);
+}
+
+}  // namespace compositor