[Chromoting] Implement DualBufferFrameConsumer

remoting/client/shared_frame_video_renderer.cc

Index: remoting/client/shared_frame_video_renderer.cc
diff --git a/remoting/client/shared_frame_video_renderer.cc b/remoting/client/shared_frame_video_renderer.cc
new file mode 100644
index 0000000000000000000000000000000000000000..0b18754995778e4eabbcdfd1a3589ec25e1a7804
--- /dev/null
+++ b/remoting/client/shared_frame_video_renderer.cc
@@ -0,0 +1,102 @@
+// 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 "remoting/client/shared_frame_video_renderer.h"
+
+#include "base/bind.h"
+#include "base/bind_helpers.h"
+#include "base/location.h"
+#include "base/memory/ptr_util.h"
+#include "third_party/webrtc/modules/desktop_capture/desktop_frame.h"
+#include "third_party/webrtc/modules/desktop_capture/shared_desktop_frame.h"
+
+namespace remoting {
+
+SharedFrameVideoRenderer::SharedFrameVideoRenderer(
+    base::Callback<void(std::unique_ptr<webrtc::DesktopFrame>)> callback,
+    scoped_refptr<base::SingleThreadTaskRunner> task_runner,
+    protocol::FrameConsumer::PixelFormat format)
+    : callback_(callback),
+      task_runner_(task_runner),
+      pixel_format_(format),
+      weak_factory_(this) {
+  thread_checker_.DetachFromThread();
+}
+
+SharedFrameVideoRenderer::~SharedFrameVideoRenderer() {
+  DCHECK(thread_checker_.CalledOnValidThread());
+}
+
+
+void SharedFrameVideoRenderer::SetUnderlyingVideoRenderer(
+    std::unique_ptr<protocol::VideoRenderer> renderer) {
+  underlying_video_renderer_ = std::move(renderer);
+}
+
+bool SharedFrameVideoRenderer::Initialize(
+    const ClientContext& client_context,
+    protocol::FrameStatsConsumer* perf_tracker) {
+  DCHECK(thread_checker_.CalledOnValidThread());
+  return underlying_video_renderer_->Initialize(client_context, perf_tracker);
+}
+
+void SharedFrameVideoRenderer::OnSessionConfig(
+    const protocol::SessionConfig& config) {
+  DCHECK(thread_checker_.CalledOnValidThread());
+  underlying_video_renderer_->OnSessionConfig(config);
+}
+
+protocol::VideoStub* SharedFrameVideoRenderer::GetVideoStub() {
+  DCHECK(thread_checker_.CalledOnValidThread());
+  return underlying_video_renderer_->GetVideoStub();
+}
+
+protocol::FrameConsumer* SharedFrameVideoRenderer::GetFrameConsumer() {
+  DCHECK(thread_checker_.CalledOnValidThread());
+  return underlying_video_renderer_->GetFrameConsumer();
+}
+
+protocol::FrameStatsConsumer*
+SharedFrameVideoRenderer::GetFrameStatsConsumer() {
+  DCHECK(thread_checker_.CalledOnValidThread());
+  return underlying_video_renderer_->GetFrameStatsConsumer();

[Sergey Ulanov, 2016/07/15 22:14:47]

How will this class get any frames, if you return
underlying_video_renderer_->GetFrameStatsConsumer() here instead of this?

[Yuwei, 2016/07/15 22:55:32]

I think you are talking about GetFrameConsumer. I'm assuming
SoftwareVideoRenderer is being used. You will do
SoftwareVideoRenderer(shared_frame_renderer_) when creating the
SoftwareVideoRenderer and SoftwareVideoRenderer::GetFrameConsumer() will just
return |this| in this case...

[Yuwei, 2016/07/18 18:53:47]

Obsolete.

[Sergey Ulanov, 2016/07/20 18:39:26]

I see. Then this class needs to be just a FrameConsumer, not a VideoRenderer.

[Yuwei, 2016/07/20 19:12:43]

Yes. It has been renamed...

+}
+
+std::unique_ptr<webrtc::DesktopFrame> SharedFrameVideoRenderer::AllocateFrame(
+    const webrtc::DesktopSize& size) {
+  DCHECK(thread_checker_.CalledOnValidThread());
+  if (!shared_frame_ || !shared_frame_->size().equals(size)) {
+    shared_frame_ = webrtc::SharedDesktopFrame::Wrap(
+        base::WrapUnique(new webrtc::BasicDesktopFrame(size)));
+  }
+  return shared_frame_->Share();
+}
+
+void SharedFrameVideoRenderer::DrawFrame(
+    std::unique_ptr<webrtc::DesktopFrame> frame,
+    const base::Closure& done) {
+  DCHECK(thread_checker_.CalledOnValidThread());
+  if (!task_runner_) {
+    callback_.Run(std::move(frame));
+    return;
+  }
+  task_runner_->PostTaskAndReply(
+      FROM_HERE, base::Bind(callback_, base::Passed(&frame)),
+      base::Bind(&SharedFrameVideoRenderer::OnFrameRendered,
+                 weak_factory_.GetWeakPtr(), done));
+}
+
+protocol::FrameConsumer::PixelFormat
+SharedFrameVideoRenderer::GetPixelFormat() {
+  return pixel_format_;
+}
+
+void SharedFrameVideoRenderer::OnFrameRendered(const base::Closure& done) {
+  DCHECK(thread_checker_.CalledOnValidThread());
+  if (done) {
+    done.Run();
+  }
+}
+
+}  // namespace remoting