Add GetFrameConsumer() in VideoRenderer.

Also moved FrameConsumer interface to remoting/protocol. This
will allow to implement video rendering in WebrtcConnectionToHost as
WebRTC stack is responsible for video decoding.

BUG=547158

Review URL: https://codereview.chromium.org/1559043004

Cr-Commit-Position: refs/heads/master@{#367600}

16 files changed, 62 insertions, 25 deletions

diff --git a/remoting/client/chromoting_client.h b/remoting/client/chromoting_client.h
index 173e1b0..48cd5f9 100644
--- a/remoting/client/chromoting_client.h
+++ b/remoting/client/chromoting_client.h
@@ -39,7 +39,6 @@ class AudioPlayer;
 class ClientContext;
 class ClientUserInterface;
 class FrameConsumerProxy;
-class FrameProducer;
 
 class ChromotingClient : public SignalStrategy::Listener,
                          public protocol::ConnectionToHost::HostEventCallback,
diff --git a/remoting/client/jni/jni_frame_consumer.cc b/remoting/client/jni/jni_frame_consumer.cc
index 25923da..066110c 100644
--- a/remoting/client/jni/jni_frame_consumer.cc
+++ b/remoting/client/jni/jni_frame_consumer.cc
@@ -115,7 +115,7 @@ void JniFrameConsumer::OnFrameRendered(const base::Closure& done) {
     done.Run();
 }
 
-FrameConsumer::PixelFormat JniFrameConsumer::GetPixelFormat() {
+protocol::FrameConsumer::PixelFormat JniFrameConsumer::GetPixelFormat() {
   return FORMAT_RGBA;
 }
 
diff --git a/remoting/client/jni/jni_frame_consumer.h b/remoting/client/jni/jni_frame_consumer.h
index 5c72e9b..e635032 100644
--- a/remoting/client/jni/jni_frame_consumer.h
+++ b/remoting/client/jni/jni_frame_consumer.h
@@ -11,7 +11,7 @@
 #include "base/macros.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/weak_ptr.h"
-#include "remoting/client/frame_consumer.h"
+#include "remoting/protocol/frame_consumer.h"
 #include "third_party/webrtc/modules/desktop_capture/desktop_geometry.h"
 
 namespace remoting {
@@ -19,7 +19,7 @@ namespace remoting {
 class ChromotingJniRuntime;
 
 // FrameConsumer implementation that draws onto a JNI direct byte buffer.
-class JniFrameConsumer : public FrameConsumer {
+class JniFrameConsumer : public protocol::FrameConsumer {
  public:
   // Does not take ownership of |jni_runtime|.
   explicit JniFrameConsumer(ChromotingJniRuntime* jni_runtime);
diff --git a/remoting/client/plugin/pepper_video_renderer_2d.cc b/remoting/client/plugin/pepper_video_renderer_2d.cc
index 4e6e4ba..978335b 100644
--- a/remoting/client/plugin/pepper_video_renderer_2d.cc
+++ b/remoting/client/plugin/pepper_video_renderer_2d.cc
@@ -114,6 +114,12 @@ protocol::VideoStub* PepperVideoRenderer2D::GetVideoStub() {
   return software_video_renderer_->GetVideoStub();
 }
 
+protocol::FrameConsumer* PepperVideoRenderer2D::GetFrameConsumer() {
+  DCHECK(thread_checker_.CalledOnValidThread());
+
+  return software_video_renderer_->GetFrameConsumer();
+}
+
 scoped_ptr<webrtc::DesktopFrame> PepperVideoRenderer2D::AllocateFrame(
     const webrtc::DesktopSize& size) {
   DCHECK(thread_checker_.CalledOnValidThread());
@@ -187,7 +193,7 @@ void PepperVideoRenderer2D::DrawFrame(scoped_ptr<webrtc::DesktopFrame> frame,
   Flush();
 }
 
-FrameConsumer::PixelFormat PepperVideoRenderer2D::GetPixelFormat() {
+protocol::FrameConsumer::PixelFormat PepperVideoRenderer2D::GetPixelFormat() {
   return FORMAT_BGRA;
 }
 
diff --git a/remoting/client/plugin/pepper_video_renderer_2d.h b/remoting/client/plugin/pepper_video_renderer_2d.h
index 6a17f4d..014ccec 100644
--- a/remoting/client/plugin/pepper_video_renderer_2d.h
+++ b/remoting/client/plugin/pepper_video_renderer_2d.h
@@ -18,8 +18,8 @@
 #include "ppapi/cpp/point.h"
 #include "ppapi/cpp/view.h"
 #include "ppapi/utility/completion_callback_factory.h"
-#include "remoting/client/frame_consumer.h"
 #include "remoting/client/plugin/pepper_video_renderer.h"
+#include "remoting/protocol/frame_consumer.h"
 #include "third_party/webrtc/modules/desktop_capture/desktop_geometry.h"
 #include "third_party/webrtc/modules/desktop_capture/desktop_region.h"
 
@@ -39,7 +39,7 @@ class SoftwareVideoRenderer;
 // Video renderer that wraps SoftwareVideoRenderer and displays it using Pepper
 // 2D graphics API.
 class PepperVideoRenderer2D : public PepperVideoRenderer,
-                              public FrameConsumer {
+                              public protocol::FrameConsumer {
  public:
   PepperVideoRenderer2D();
   ~PepperVideoRenderer2D() override;
@@ -55,9 +55,10 @@ class PepperVideoRenderer2D : public PepperVideoRenderer,
   // VideoRenderer interface.
   void OnSessionConfig(const protocol::SessionConfig& config) override;
   protocol::VideoStub* GetVideoStub() override;
+  protocol::FrameConsumer* GetFrameConsumer() override;
 
  private:
-  // FrameConsumer implementation.
+  // protocol::FrameConsumer implementation.
   scoped_ptr<webrtc::DesktopFrame> AllocateFrame(
       const webrtc::DesktopSize& size) override;
   void DrawFrame(scoped_ptr<webrtc::DesktopFrame> frame,
diff --git a/remoting/client/plugin/pepper_video_renderer_3d.cc b/remoting/client/plugin/pepper_video_renderer_3d.cc
index 732b77b..4c22b14 100644
--- a/remoting/client/plugin/pepper_video_renderer_3d.cc
+++ b/remoting/client/plugin/pepper_video_renderer_3d.cc
@@ -178,6 +178,13 @@ protocol::VideoStub* PepperVideoRenderer3D::GetVideoStub() {
   return this;
 }
 
+protocol::FrameConsumer* PepperVideoRenderer3D::GetFrameConsumer() {
+  // GetFrameConsumer() is used only for WebRTC-based connections which are not
+  // supported by the plugin.
+  NOTREACHED();
+  return nullptr;
+}
+
 void PepperVideoRenderer3D::ProcessVideoPacket(scoped_ptr<VideoPacket> packet,
                                                const base::Closure& done) {
   base::ScopedClosureRunner done_runner(done);
diff --git a/remoting/client/plugin/pepper_video_renderer_3d.h b/remoting/client/plugin/pepper_video_renderer_3d.h
index 414cffa..d7df94f 100644
--- a/remoting/client/plugin/pepper_video_renderer_3d.h
+++ b/remoting/client/plugin/pepper_video_renderer_3d.h
@@ -45,6 +45,7 @@ class PepperVideoRenderer3D : public PepperVideoRenderer,
   // VideoRenderer interface.
   void OnSessionConfig(const protocol::SessionConfig& config) override;
   protocol::VideoStub* GetVideoStub() override;
+  protocol::FrameConsumer* GetFrameConsumer() override;
 
   // protocol::VideoStub interface.
   void ProcessVideoPacket(scoped_ptr<VideoPacket> packet,
diff --git a/remoting/client/software_video_renderer.cc b/remoting/client/software_video_renderer.cc
index 9726cd5..2fa0fb2 100644
--- a/remoting/client/software_video_renderer.cc
+++ b/remoting/client/software_video_renderer.cc
@@ -14,11 +14,11 @@
 #include "base/single_thread_task_runner.h"
 #include "base/task_runner_util.h"
 #include "remoting/base/util.h"
-#include "remoting/client/frame_consumer.h"
 #include "remoting/codec/video_decoder.h"
 #include "remoting/codec/video_decoder_verbatim.h"
 #include "remoting/codec/video_decoder_vpx.h"
 #include "remoting/proto/video.pb.h"
+#include "remoting/protocol/frame_consumer.h"
 #include "remoting/protocol/session_config.h"
 #include "third_party/libyuv/include/libyuv/convert_argb.h"
 #include "third_party/webrtc/modules/desktop_capture/desktop_frame.h"
@@ -72,7 +72,7 @@ scoped_ptr<webrtc::DesktopFrame> DoDecodeFrame(
 
 SoftwareVideoRenderer::SoftwareVideoRenderer(
     scoped_refptr<base::SingleThreadTaskRunner> decode_task_runner,
-    FrameConsumer* consumer,
+    protocol::FrameConsumer* consumer,
     protocol::PerformanceTracker* perf_tracker)
     : decode_task_runner_(decode_task_runner),
       consumer_(consumer),
@@ -100,7 +100,7 @@ void SoftwareVideoRenderer::OnSessionConfig(
     NOTREACHED() << "Invalid Encoding found: " << codec;
   }
 
-  if (consumer_->GetPixelFormat() == FrameConsumer::FORMAT_RGBA) {
+  if (consumer_->GetPixelFormat() == protocol::FrameConsumer::FORMAT_RGBA) {
     decoder_ =
         make_scoped_ptr(new RgbToBgrVideoDecoderFilter(std::move(decoder_)));
   }
@@ -111,6 +111,10 @@ protocol::VideoStub* SoftwareVideoRenderer::GetVideoStub() {
   return this;
 }
 
+protocol::FrameConsumer* SoftwareVideoRenderer::GetFrameConsumer() {
+  return consumer_;
+}
+
 void SoftwareVideoRenderer::ProcessVideoPacket(scoped_ptr<VideoPacket> packet,
                                                const base::Closure& done) {
   DCHECK(thread_checker_.CalledOnValidThread());
diff --git a/remoting/client/software_video_renderer.h b/remoting/client/software_video_renderer.h
index b88fb45..5951cf3 100644
--- a/remoting/client/software_video_renderer.h
+++ b/remoting/client/software_video_renderer.h
@@ -27,10 +27,10 @@ class DesktopFrame;
 
 namespace remoting {
 
-class FrameConsumer;
 class VideoDecoder;
 
 namespace protocol {
+class FrameConsumer;
 class PerformanceTracker;
 }  // namespace protocol
 
@@ -45,13 +45,14 @@ class SoftwareVideoRenderer : public protocol::VideoRenderer,
   // tracking is disabled in that case.
   SoftwareVideoRenderer(
       scoped_refptr<base::SingleThreadTaskRunner> decode_task_runner,
-      FrameConsumer* consumer,
+      protocol::FrameConsumer* consumer,
       protocol::PerformanceTracker* perf_tracker);
   ~SoftwareVideoRenderer() override;
 
   // VideoRenderer interface.
   void OnSessionConfig(const protocol::SessionConfig& config) override;
   protocol::VideoStub* GetVideoStub() override;
+  protocol::FrameConsumer* GetFrameConsumer() override;
 
   // protocol::VideoStub interface.
   void ProcessVideoPacket(scoped_ptr<VideoPacket> packet,
@@ -64,7 +65,7 @@ class SoftwareVideoRenderer : public protocol::VideoRenderer,
   void OnFrameRendered(int32_t frame_id, const base::Closure& done);
 
   scoped_refptr<base::SingleThreadTaskRunner> decode_task_runner_;
-  FrameConsumer* consumer_;
+  protocol::FrameConsumer* consumer_;
   protocol::PerformanceTracker* perf_tracker_;
 
   scoped_ptr<VideoDecoder> decoder_;
diff --git a/remoting/client/software_video_renderer_unittest.cc b/remoting/client/software_video_renderer_unittest.cc
index d57e7b9..9b658fd 100644
--- a/remoting/client/software_video_renderer_unittest.cc
+++ b/remoting/client/software_video_renderer_unittest.cc
@@ -14,9 +14,9 @@
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "base/threading/thread.h"
-#include "remoting/client/frame_consumer.h"
 #include "remoting/codec/video_encoder_verbatim.h"
 #include "remoting/proto/video.pb.h"
+#include "remoting/protocol/frame_consumer.h"
 #include "remoting/protocol/session_config.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/webrtc/modules/desktop_capture/desktop_frame.h"
@@ -30,7 +30,7 @@ namespace {
 const int kFrameWidth = 200;
 const int kFrameHeight = 200;
 
-class TestFrameConsumer : public FrameConsumer {
+class TestFrameConsumer : public protocol::FrameConsumer {
  public:
   TestFrameConsumer() {}
   ~TestFrameConsumer() override {}
diff --git a/remoting/client/frame_consumer.h b/remoting/protocol/frame_consumer.h
index 792d2f6..87c8ca2 100644
--- a/remoting/client/frame_consumer.h
+++ b/remoting/protocol/frame_consumer.h
@@ -1,21 +1,19 @@
-// Copyright (c) 2012 The Chromium Authors. All rights reserved.
+// 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.
 
-#ifndef REMOTING_CLIENT_FRAME_CONSUMER_H_
-#define REMOTING_CLIENT_FRAME_CONSUMER_H_
+#ifndef REMOTING_PROTOCOL_FRAME_CONSUMER_H_
+#define REMOTING_PROTOCOL_FRAME_CONSUMER_H_
 
 #include "base/macros.h"
 
 namespace webrtc {
 class DesktopFrame;
-class DesktopRect;
-class DesktopRegion;
 class DesktopSize;
-class DesktopVector;
 }  // namespace webrtc
 
 namespace remoting {
+namespace protocol {
 
 class FrameConsumer {
  public:
@@ -42,6 +40,7 @@ class FrameConsumer {
   DISALLOW_COPY_AND_ASSIGN(FrameConsumer);
 };
 
+}  // namespace protocol
 }  // namespace remoting
 
-#endif  // REMOTING_CLIENT_FRAME_CONSUMER_H_
+#endif  // REMOTING_PROTOCOL_FRAME_CONSUMER_H_
diff --git a/remoting/protocol/video_renderer.h b/remoting/protocol/video_renderer.h
index 4d2c05f..85ccb0d 100644
--- a/remoting/protocol/video_renderer.h
+++ b/remoting/protocol/video_renderer.h
@@ -8,11 +8,16 @@
 namespace remoting {
 namespace protocol {
 
+class FrameConsumer;
 class SessionConfig;
 class VideoStub;
 
 // VideoRenderer is responsible for decoding and displaying incoming video
-// stream.
+// stream. This interface is used by ConnectionToHost implementations to
+// render received video frames. ConnectionToHost may feed encoded frames to the
+// VideoStub or decode them and pass decoded frames to the FrameConsumer.
+//
+// TODO(sergeyu): Reconsider this design.
 class VideoRenderer {
  public:
   virtual ~VideoRenderer() {}
@@ -23,6 +28,9 @@ class VideoRenderer {
 
   // Returns the VideoStub interface of this renderer.
   virtual VideoStub* GetVideoStub() = 0;
+
+  // Returns the FrameConsumer interface for this renderer.
+  virtual FrameConsumer* GetFrameConsumer() = 0;
 };
 
 }  // namespace protocol;
diff --git a/remoting/remoting_srcs.gypi b/remoting/remoting_srcs.gypi
index 7a157a2..656b4e2 100644
--- a/remoting/remoting_srcs.gypi
+++ b/remoting/remoting_srcs.gypi
@@ -108,6 +108,7 @@
       'protocol/datagram_channel_factory.h',
       'protocol/errors.cc',
       'protocol/errors.h',
+      'protocol/frame_consumer.h',
       'protocol/host_control_dispatcher.cc',
       'protocol/host_control_dispatcher.h',
       'protocol/host_event_dispatcher.cc',
@@ -263,7 +264,6 @@
       'client/client_user_interface.h',
       'client/empty_cursor_filter.cc',
       'client/empty_cursor_filter.h',
-      'client/frame_consumer.h',
       'client/key_event_mapper.cc',
       'client/key_event_mapper.h',
       'client/normalizing_input_filter_cros.cc',
diff --git a/remoting/test/protocol_perftest.cc b/remoting/test/protocol_perftest.cc
index 0bd0c30..bbafe94 100644
--- a/remoting/test/protocol_perftest.cc
+++ b/remoting/test/protocol_perftest.cc
@@ -123,6 +123,10 @@ class ProtocolPerfTest
   // VideoRenderer interface.
   void OnSessionConfig(const protocol::SessionConfig& config) override {}
   protocol::VideoStub* GetVideoStub() override { return this; }
+  protocol::FrameConsumer* GetFrameConsumer() override {
+    NOTREACHED();
+    return nullptr;
+  }
 
   // protocol::VideoStub interface.
   void ProcessVideoPacket(scoped_ptr<VideoPacket> video_packet,
diff --git a/remoting/test/test_video_renderer.cc b/remoting/test/test_video_renderer.cc
index 5355772..42bd96f 100644
--- a/remoting/test/test_video_renderer.cc
+++ b/remoting/test/test_video_renderer.cc
@@ -310,6 +310,12 @@ protocol::VideoStub* TestVideoRenderer::GetVideoStub() {
   return this;
 }
 
+protocol::FrameConsumer* TestVideoRenderer::GetFrameConsumer() {
+  DCHECK(thread_checker_.CalledOnValidThread());
+  NOTREACHED();
+  return nullptr;
+}
+
 void TestVideoRenderer::ProcessVideoPacket(scoped_ptr<VideoPacket> video_packet,
                                            const base::Closure& done) {
   DCHECK(thread_checker_.CalledOnValidThread());
diff --git a/remoting/test/test_video_renderer.h b/remoting/test/test_video_renderer.h
index c09ad42..1ea4905 100644
--- a/remoting/test/test_video_renderer.h
+++ b/remoting/test/test_video_renderer.h
@@ -41,6 +41,7 @@ class TestVideoRenderer : public protocol::VideoRenderer,
   // VideoRenderer interface.
   void OnSessionConfig(const protocol::SessionConfig& config) override;
   protocol::VideoStub* GetVideoStub() override;
+  protocol::FrameConsumer* GetFrameConsumer() override;
 
   // protocol::VideoStub interface.
   void ProcessVideoPacket(scoped_ptr<VideoPacket> video_packet,