Allow to use the DefaultRendererFactory from a Utility Process

media/mojo/services/mojo_video_renderer_sink_adapter.cc

Index: media/mojo/services/mojo_video_renderer_sink_adapter.cc
diff --git a/media/mojo/services/mojo_video_renderer_sink_adapter.cc b/media/mojo/services/mojo_video_renderer_sink_adapter.cc
new file mode 100644
index 0000000000000000000000000000000000000000..609e1b70e36baf11eb52b70bb3527f27ae91fbde
--- /dev/null
+++ b/media/mojo/services/mojo_video_renderer_sink_adapter.cc
@@ -0,0 +1,83 @@
+// Copyright 2017 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 "media/mojo/services/mojo_video_renderer_sink_adapter.h"
+
+#include "media/mojo/common/media_type_converters.h"
+
+namespace media {
+
+MojoVideoRendererSinkAdapter::MojoVideoRendererSinkAdapter(
+    const scoped_refptr<base::SingleThreadTaskRunner>& task_runner)
+    : binding_(this),
+      task_runner_(task_runner),
+      started_(false),
+      render_callback_(nullptr) {}
+
+MojoVideoRendererSinkAdapter::~MojoVideoRendererSinkAdapter() {}
+
+void MojoVideoRendererSinkAdapter::Initialize(
+    mojom::VideoRendererSinkPtr sink) {
+  CHECK(!sink_);
+  CHECK(task_runner_->BelongsToCurrentThread());
+  sink_ = std::move(sink);
+}
+
+void MojoVideoRendererSinkAdapter::Start(
+    media::VideoRendererSink::RenderCallback* callback) {
+  CHECK(task_runner_->BelongsToCurrentThread());
+  CHECK(sink_);
+  CHECK(!started_);
+  CHECK(callback);
+  render_callback_ = callback;
+  started_ = true;
+
+  mojom::VideoRendererSinkRenderCallbackAssociatedPtrInfo
+      render_callback_ptr_info;
+  binding_.Bind(&render_callback_ptr_info, sink_.associated_group());
+
+  sink_->Start(std::move(render_callback_ptr_info));
+}
+
+void MojoVideoRendererSinkAdapter::Stop() {
+  CHECK(task_runner_->BelongsToCurrentThread());
+  CHECK(started_);
+  started_ = false;
+  render_callback_ = nullptr;
+  sink_->Stop();
+}
+
+void MojoVideoRendererSinkAdapter::PaintSingleFrame(
+    const scoped_refptr<VideoFrame>& frame,
+    bool repaint_duplicate_frame) {
+  CHECK(task_runner_->BelongsToCurrentThread());
+  sink_->PaintSingleFrame(mojom::VideoFrame::From(frame),
+                          repaint_duplicate_frame);
+}
+
+void MojoVideoRendererSinkAdapter::Render(
+    base::TimeTicks deadline_min,
+    base::TimeTicks deadline_max,
+    bool background_rendering,
+    const media::mojom::VideoRendererSinkRenderCallback::RenderCallback&
+        mojo_callback) {
+  CHECK(task_runner_->BelongsToCurrentThread());
+
+  if (!started_) {
+    mojo_callback.Run(nullptr);
+    return;
+  }
+
+  scoped_refptr<VideoFrame> frame = render_callback_->Render(
+      deadline_min, deadline_max, background_rendering);
+  CHECK(frame->storage_type() == media::VideoFrame::STORAGE_MOJO_SHARED_BUFFER);
+  mojo_callback.Run(mojom::VideoFrame::From(frame));
+}
+
+void MojoVideoRendererSinkAdapter::OnFrameDropped() {
+  CHECK(task_runner_->BelongsToCurrentThread());
+  render_callback_->OnFrameDropped();
+}
+
+}  // namespace media