[Remoting Android] DisplayUpdaterFactory cleanups

remoting/client/jni/jni_video_renderer.cc

Index: remoting/client/jni/jni_video_renderer.cc
diff --git a/remoting/client/jni/jni_frame_consumer.cc b/remoting/client/jni/jni_video_renderer.cc
similarity index 81%
rename from remoting/client/jni/jni_frame_consumer.cc
rename to remoting/client/jni/jni_video_renderer.cc
index f0f0e5eb000d313dd6e4dcd7c1806eb6fd59e51a..1ac7dd47dc3736b8fe359e5cf8c6a84114e8e5df 100644
--- a/remoting/client/jni/jni_frame_consumer.cc
+++ b/remoting/client/jni/jni_video_renderer.cc
@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#include "remoting/client/jni/jni_frame_consumer.h"
+#include "remoting/client/jni/jni_video_renderer.h"
 
 #include <stdint.h>
 
@@ -22,7 +22,7 @@
 
 namespace remoting {
 
-class JniFrameConsumer::Renderer {
+class JniVideoRenderer::Renderer {
  public:
   Renderer(ChromotingJniRuntime* jni_runtime,
            base::WeakPtr<JniDisplayHandler> display)
@@ -51,7 +51,7 @@ class JniFrameConsumer::Renderer {
 };
 
 // Function called on the display thread to render the frame.
-void JniFrameConsumer::Renderer::RenderFrame(
+void JniVideoRenderer::Renderer::RenderFrame(
     std::unique_ptr<webrtc::DesktopFrame> frame) {
   DCHECK(jni_runtime_->display_task_runner()->BelongsToCurrentThread());
   if (!display_handler_) {
@@ -92,24 +92,24 @@ void JniFrameConsumer::Renderer::RenderFrame(
   display_handler_->RedrawCanvas();
 }
 
-JniFrameConsumer::JniFrameConsumer(
+JniVideoRenderer::JniVideoRenderer(
     ChromotingJniRuntime* jni_runtime,
     base::WeakPtr<JniDisplayHandler> display)
     : jni_runtime_(jni_runtime),
       renderer_(new Renderer(jni_runtime, display)),
       weak_factory_(this) {}
 
-JniFrameConsumer::~JniFrameConsumer() {
+JniVideoRenderer::~JniVideoRenderer() {
   jni_runtime_->display_task_runner()->DeleteSoon(FROM_HERE,
                                                   renderer_.release());
 }
 
-std::unique_ptr<webrtc::DesktopFrame> JniFrameConsumer::AllocateFrame(
+std::unique_ptr<webrtc::DesktopFrame> JniVideoRenderer::AllocateFrame(
     const webrtc::DesktopSize& size) {
   return base::WrapUnique(new webrtc::BasicDesktopFrame(size));
 }
 
-void JniFrameConsumer::DrawFrame(std::unique_ptr<webrtc::DesktopFrame> frame,
+void JniVideoRenderer::DrawFrame(std::unique_ptr<webrtc::DesktopFrame> frame,
                                  const base::Closure& done) {
   DCHECK(jni_runtime_->network_task_runner()->BelongsToCurrentThread());
 
@@ -117,41 +117,38 @@ void JniFrameConsumer::DrawFrame(std::unique_ptr<webrtc::DesktopFrame> frame,
       FROM_HERE,
       base::Bind(&Renderer::RenderFrame, base::Unretained(renderer_.get()),
                  base::Passed(&frame)),
-      base::Bind(&JniFrameConsumer::OnFrameRendered, weak_factory_.GetWeakPtr(),
+      base::Bind(&JniVideoRenderer::OnFrameRendered, weak_factory_.GetWeakPtr(),
                  done));
 }
 
-void JniFrameConsumer::OnFrameRendered(const base::Closure& done) {
+void JniVideoRenderer::OnFrameRendered(const base::Closure& done) {
   DCHECK(jni_runtime_->network_task_runner()->BelongsToCurrentThread());
 
   if (!done.is_null())
     done.Run();
 }
 
-protocol::FrameConsumer::PixelFormat JniFrameConsumer::GetPixelFormat() {
+protocol::FrameConsumer::PixelFormat JniVideoRenderer::GetPixelFormat() {
   return FORMAT_RGBA;
 }
 
-void JniFrameConsumer::OnSessionConfig(const protocol::SessionConfig& config) {
-  DCHECK(video_renderer_);
+void JniVideoRenderer::OnSessionConfig(const protocol::SessionConfig& config) {
   return video_renderer_->OnSessionConfig(config);
 }
 
-protocol::VideoStub* JniFrameConsumer::GetVideoStub() {
-  DCHECK(video_renderer_);
+protocol::VideoStub* JniVideoRenderer::GetVideoStub() {
   return video_renderer_->GetVideoStub();
 }
 
-protocol::FrameConsumer* JniFrameConsumer::GetFrameConsumer() {
-  DCHECK(video_renderer_);
+protocol::FrameConsumer* JniVideoRenderer::GetFrameConsumer() {
   return video_renderer_->GetFrameConsumer();
 }
 
-void JniFrameConsumer::Initialize(
-    scoped_refptr<base::SingleThreadTaskRunner> decode_task_runner,
-    protocol::PerformanceTracker* perf_tracker) {
-  video_renderer_.reset(new SoftwareVideoRenderer(decode_task_runner, this,
-                                                  perf_tracker));
+void JniVideoRenderer::Initialize(const ClientContext& context,
+                                  protocol::PerformanceTracker* perf_tracker) {
+  DCHECK(!video_renderer_);
+  video_renderer_.reset(new SoftwareVideoRenderer(context.decode_task_runner(),
+                                                  this, perf_tracker));
 }
 
 }  // namespace remoting