[Remoting Android] DisplayUpdaterFactory cleanups

This CL resolves comments in 2055143002 after CL being committed:

* Move Initialize() function to protocol::VideoRenderer interface
* Rename JniFrameConsumer to JniVideoRenderer
* Resolves other comments

BUG=385924

Review-Url: https://codereview.chromium.org/2101833002
Cr-Commit-Position: refs/heads/master@{#403263}

remoting/android/BUILD.gn

@@ -45,14 +45,13 @@ shared_library("remoting_client_jni") {
     "//remoting/client/jni/jni_client.h",
     "//remoting/client/jni/jni_display_handler.cc",
     "//remoting/client/jni/jni_display_handler.h",
-    "//remoting/client/jni/jni_frame_consumer.cc",
-    "//remoting/client/jni/jni_frame_consumer.h",
     "//remoting/client/jni/jni_gl_display_handler.cc",
     "//remoting/client/jni/jni_gl_display_handler.h",
     "//remoting/client/jni/jni_pairing_secret_fetcher.cc",
     "//remoting/client/jni/jni_pairing_secret_fetcher.h",
     "//remoting/client/jni/jni_touch_event_data.cc",
     "//remoting/client/jni/jni_touch_event_data.h",
+    "//remoting/client/jni/jni_video_renderer.cc",
     "//remoting/client/jni/jni_video_renderer.h",
     "//remoting/client/jni/remoting_jni_onload.cc",
     "//remoting/client/jni/remoting_jni_registrar.cc",

remoting/client/jni/chromoting_jni_instance.cc

@@ -31,6 +31,7 @@
 #include "remoting/protocol/network_settings.h"
 #include "remoting/protocol/performance_tracker.h"
 #include "remoting/protocol/transport_context.h"
+#include "remoting/protocol/video_renderer.h"
 #include "remoting/signaling/server_log_entry.h"
 #include "ui/events/keycodes/dom/keycode_converter.h"
 
@@ -53,7 +54,7 @@ ChromotingJniInstance::ChromotingJniInstance(
     base::WeakPtr<JniClient> jni_client,
     base::WeakPtr<JniPairingSecretFetcher> secret_fetcher,
     std::unique_ptr<protocol::CursorShapeStub> cursor_shape_stub,
-    std::unique_ptr<JniVideoRenderer> video_renderer,
+    std::unique_ptr<protocol::VideoRenderer> video_renderer,
     const std::string& username,
     const std::string& auth_token,
     const std::string& host_jid,
@@ -381,7 +382,7 @@ void ChromotingJniInstance::ConnectToHostOnNetworkThread() {
 
   perf_tracker_.reset(new protocol::PerformanceTracker());
 
-  video_renderer_->Initialize(client_context_->decode_task_runner(),
+  video_renderer_->Initialize(*client_context_,
                               perf_tracker_.get());
 
   if (!audio_player_) {

remoting/client/jni/chromoting_jni_instance.h

@@ -28,12 +28,12 @@ class ClipboardEvent;
 class CursorShapeInfo;
 class PerformanceTracker;
 class FrameConsumer;
+class VideoRenderer;
 }  // namespace protocol
 
 class AudioPlayerAndroid;
 class ChromotingJniRuntime;
 class JniClient;
-class JniVideoRenderer;
 class DisplayHandler;
 class JniPairingSecretFetcher;
 
@@ -52,7 +52,7 @@ class ChromotingJniInstance
                         base::WeakPtr<JniClient> jni_client,
                         base::WeakPtr<JniPairingSecretFetcher> secret_fetcher,
                         std::unique_ptr<protocol::CursorShapeStub> cursor_stub,
-                        std::unique_ptr<JniVideoRenderer> video_renderer,
+                        std::unique_ptr<protocol::VideoRenderer> video_renderer,
                         const std::string& username,
                         const std::string& auth_token,
                         const std::string& host_jid,
@@ -169,7 +169,7 @@ class ChromotingJniInstance
   std::unique_ptr<ClientContext> client_context_;
   std::unique_ptr<protocol::PerformanceTracker> perf_tracker_;
   std::unique_ptr<protocol::CursorShapeStub> cursor_shape_stub_;
-  std::unique_ptr<JniVideoRenderer> video_renderer_;
+  std::unique_ptr<protocol::VideoRenderer> video_renderer_;
   std::unique_ptr<ChromotingClient> client_;
   XmppSignalStrategy::XmppServerConfig xmpp_config_;
   std::unique_ptr<XmppSignalStrategy> signaling_;  // Must outlive client_

remoting/client/jni/display_updater_factory.h

@@ -12,13 +12,10 @@
 namespace remoting {
 
 namespace protocol {
-
 class CursorShapeStub;
-
+class VideoRenderer;
 }  // namespace protocol
 
-class JniVideoRenderer;
-
 // Interface for creating objects to update image (desktop frame or cursor
 // shape) to display. Factory functions can be called on any thread but the
 // returned object should be used on the network thread.
@@ -28,7 +25,7 @@ class DisplayUpdaterFactory {
 
   virtual std::unique_ptr<protocol::CursorShapeStub>
   CreateCursorShapeStub() = 0;
-  virtual std::unique_ptr<JniVideoRenderer> CreateVideoRenderer() = 0;
+  virtual std::unique_ptr<protocol::VideoRenderer> CreateVideoRenderer() = 0;
 
  protected:
   DisplayUpdaterFactory() {}

remoting/client/jni/jni_display_handler.cc

@@ -12,7 +12,6 @@
 #include "jni/Display_jni.h"
 #include "remoting/client/jni/chromoting_jni_runtime.h"
 #include "remoting/client/jni/jni_client.h"
-#include "remoting/client/jni/jni_frame_consumer.h"
 #include "remoting/client/jni/jni_video_renderer.h"
 
 using base::android::JavaParamRef;
@@ -88,12 +87,13 @@ std::unique_ptr<protocol::CursorShapeStub>
 JniDisplayHandler::CreateCursorShapeStub() {
   return base::WrapUnique(
       new DisplayCursorShapeStub(weak_factory_.GetWeakPtr(),
-                                    runtime_->display_task_runner()));
+                                 runtime_->display_task_runner()));
 }
 
-std::unique_ptr<JniVideoRenderer> JniDisplayHandler::CreateVideoRenderer() {
+std::unique_ptr<protocol::VideoRenderer>
+JniDisplayHandler::CreateVideoRenderer() {
   return base::WrapUnique(
-      new JniFrameConsumer(runtime_, weak_factory_.GetWeakPtr()));
+      new JniVideoRenderer(runtime_, weak_factory_.GetWeakPtr()));
 }
 
 // static

remoting/client/jni/jni_display_handler.h

@@ -16,10 +16,10 @@ namespace remoting {
 
 namespace protocol {
 class CursorShapeInfo;
+class VideoRenderer;
 }  // namespace protocol
 
 class ChromotingJniRuntime;
-class JniVideoRenderer;
 
 // Handles display operations. Must be called and deleted on the display thread
 // unless otherwise noted.
@@ -35,7 +35,7 @@ class JniDisplayHandler : public DisplayUpdaterFactory {
 
   // DisplayUpdaterFactory overrides (functions can be called on any thread).
   std::unique_ptr<protocol::CursorShapeStub> CreateCursorShapeStub() override;
-  std::unique_ptr<JniVideoRenderer> CreateVideoRenderer() override;
+  std::unique_ptr<protocol::VideoRenderer> CreateVideoRenderer() override;
 
   // Creates a new Bitmap object to store a video frame. Can be called on any
   // thread.

remoting/client/jni/jni_frame_consumer.h

-// Copyright 2013 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_JNI_JNI_FRAME_CONSUMER_H_
-#define REMOTING_CLIENT_JNI_JNI_FRAME_CONSUMER_H_
-
-#include <list>
-#include <memory>
-
-#include "base/compiler_specific.h"
-#include "base/macros.h"
-#include "base/memory/weak_ptr.h"
-#include "remoting/client/jni/jni_video_renderer.h"
-#include "remoting/protocol/frame_consumer.h"
-#include "third_party/webrtc/modules/desktop_capture/desktop_geometry.h"
-
-namespace remoting {
-
-class ChromotingJniRuntime;
-class JniClient;
-class JniDisplayHandler;
-class SoftwareVideoRenderer;
-
-// FrameConsumer and VideoRenderer implementation that draws onto a JNI direct
-// byte buffer.
-class JniFrameConsumer : public protocol::FrameConsumer,
-                         public JniVideoRenderer {
- public:
-  JniFrameConsumer(
-      ChromotingJniRuntime* jni_runtime,
-      base::WeakPtr<JniDisplayHandler> display);
-
-  ~JniFrameConsumer() override;
-
-  // FrameConsumer implementation.
-  std::unique_ptr<webrtc::DesktopFrame> AllocateFrame(
-      const webrtc::DesktopSize& size) override;
-  void DrawFrame(std::unique_ptr<webrtc::DesktopFrame> frame,
-                 const base::Closure& done) override;
-  PixelFormat GetPixelFormat() override;
-
-  // JniVideoRenderer implementation.
-  void OnSessionConfig(const protocol::SessionConfig& config) override;
-  protocol::VideoStub* GetVideoStub() override;
-  protocol::FrameConsumer* GetFrameConsumer() override;
-  void Initialize(
-        scoped_refptr<base::SingleThreadTaskRunner> decode_task_runner,
-        protocol::PerformanceTracker* perf_tracker) override;
-
- private:
-  class Renderer;
-
-  void OnFrameRendered(const base::Closure& done);
-
-  // Used to obtain task runner references and make calls to Java methods.
-  ChromotingJniRuntime* jni_runtime_;
-
-  std::unique_ptr<SoftwareVideoRenderer> video_renderer_;
-
-  // Renderer object used to render the frames on the display thread.
-  std::unique_ptr<Renderer> renderer_;
-
-  base::WeakPtrFactory<JniFrameConsumer> weak_factory_;
-
-  DISALLOW_COPY_AND_ASSIGN(JniFrameConsumer);
-};
-
-}  // namespace remoting
-
-#endif

remoting/client/jni/jni_gl_display_handler.cc

@@ -20,10 +20,10 @@ JniGlDisplayHandler::CreateCursorShapeStub() {
   return std::unique_ptr<protocol::CursorShapeStub>();
 }
 
-std::unique_ptr<JniVideoRenderer>
+std::unique_ptr<protocol::VideoRenderer>
 JniGlDisplayHandler::CreateVideoRenderer() {
   NOTIMPLEMENTED();
-  return std::unique_ptr<JniVideoRenderer>();
+  return std::unique_ptr<protocol::VideoRenderer>();
 }
 
 // static

remoting/client/jni/jni_gl_display_handler.h

@@ -26,7 +26,7 @@ class JniGlDisplayHandler : public DisplayUpdaterFactory {
 
   // DisplayUpdaterFactory overrides.
   std::unique_ptr<protocol::CursorShapeStub> CreateCursorShapeStub() override;
-  std::unique_ptr<JniVideoRenderer> CreateVideoRenderer() override;
+  std::unique_ptr<protocol::VideoRenderer> CreateVideoRenderer() override;
 
   static bool RegisterJni(JNIEnv* env);
 

remoting/client/jni/jni_frame_consumer.cc → remoting/client/jni/jni_video_renderer.cc

-// Copyright 2013 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.
 
-#include "remoting/client/jni/jni_frame_consumer.h"
+#include "remoting/client/jni/jni_video_renderer.h"
 
 #include <stdint.h>
 
@@ -15,14 +15,13 @@
 #include "remoting/client/jni/chromoting_jni_runtime.h"
 #include "remoting/client/jni/jni_client.h"
 #include "remoting/client/jni/jni_display_handler.h"
-#include "remoting/client/software_video_renderer.h"
 #include "third_party/webrtc/modules/desktop_capture/desktop_frame.h"
 #include "third_party/webrtc/modules/desktop_capture/desktop_region.h"
 #include "ui/gfx/android/java_bitmap.h"
 
 namespace remoting {
 
-class JniFrameConsumer::Renderer {
+class JniVideoRenderer::Renderer {
  public:
   Renderer(ChromotingJniRuntime* jni_runtime,
            base::WeakPtr<JniDisplayHandler> display)
@@ -51,7 +50,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 +91,25 @@ void JniFrameConsumer::Renderer::RenderFrame(
   display_handler_->RedrawCanvas();
 }
 
-JniFrameConsumer::JniFrameConsumer(
+JniVideoRenderer::JniVideoRenderer(
     ChromotingJniRuntime* jni_runtime,
     base::WeakPtr<JniDisplayHandler> display)
     : jni_runtime_(jni_runtime),
+      software_video_renderer_(this),
       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,36 @@ 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_);
-  return video_renderer_->OnSessionConfig(config);
+void JniVideoRenderer::OnSessionConfig(const protocol::SessionConfig& config) {
+  return software_video_renderer_.OnSessionConfig(config);
 }
 
-protocol::VideoStub* JniFrameConsumer::GetVideoStub() {
-  DCHECK(video_renderer_);
-  return video_renderer_->GetVideoStub();
+protocol::VideoStub* JniVideoRenderer::GetVideoStub() {
+  return software_video_renderer_.GetVideoStub();
 }
 
-protocol::FrameConsumer* JniFrameConsumer::GetFrameConsumer() {
-  DCHECK(video_renderer_);
-  return video_renderer_->GetFrameConsumer();
+protocol::FrameConsumer* JniVideoRenderer::GetFrameConsumer() {
+  return software_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));
+bool JniVideoRenderer::Initialize(const ClientContext& context,
+                                  protocol::PerformanceTracker* perf_tracker) {
+  return software_video_renderer_.Initialize(context, perf_tracker);
 }
 
 }  // namespace remoting

remoting/client/jni/jni_video_renderer.h

@@ -5,30 +5,67 @@
 #ifndef REMOTING_CLIENT_JNI_JNI_VIDEO_RENDERER_H_
 #define REMOTING_CLIENT_JNI_JNI_VIDEO_RENDERER_H_
 
-#include "base/memory/ref_counted.h"
-#include "remoting/protocol/video_renderer.h"
+#include <list>
+#include <memory>
 
-namespace base {
-class SingleThreadTaskRunner;
-}  // namespace base
+#include "base/compiler_specific.h"
+#include "base/macros.h"
+#include "base/memory/weak_ptr.h"
+#include "remoting/client/software_video_renderer.h"
+#include "remoting/protocol/frame_consumer.h"
+#include "remoting/protocol/video_renderer.h"
+#include "third_party/webrtc/modules/desktop_capture/desktop_geometry.h"
 
 namespace remoting {
 
-namespace protocol {
-class PerformanceTracker;
-}  // namespace protocol
+class ClientContext;
+class ChromotingJniRuntime;
+class JniClient;
+class JniDisplayHandler;
 
-// An extension of VideoRenderer that allows renderer to be initialized after
-// it is constructed.
-class JniVideoRenderer : public protocol::VideoRenderer {
+// FrameConsumer and VideoRenderer implementation that draws onto a JNI direct
+// byte buffer.
+class JniVideoRenderer : public protocol::FrameConsumer,
+                         public protocol::VideoRenderer {
  public:
-  ~JniVideoRenderer() override {}
-  virtual void Initialize(
-      scoped_refptr<base::SingleThreadTaskRunner> decode_task_runner,
-      protocol::PerformanceTracker* perf_tracker) = 0;
- protected:
-  JniVideoRenderer() {}
+  JniVideoRenderer(
+      ChromotingJniRuntime* jni_runtime,
+      base::WeakPtr<JniDisplayHandler> display);
+
+  ~JniVideoRenderer() override;
+
+  // FrameConsumer implementation.
+  std::unique_ptr<webrtc::DesktopFrame> AllocateFrame(
+      const webrtc::DesktopSize& size) override;
+  void DrawFrame(std::unique_ptr<webrtc::DesktopFrame> frame,
+                 const base::Closure& done) override;
+  PixelFormat GetPixelFormat() override;
+
+  // JniVideoRenderer implementation.
+  void OnSessionConfig(const protocol::SessionConfig& config) override;
+  protocol::VideoStub* GetVideoStub() override;
+  protocol::FrameConsumer* GetFrameConsumer() override;
+  bool Initialize(const ClientContext& client_context,
+                  protocol::PerformanceTracker* perf_tracker) override;
+
+ private:
+  class Renderer;
+
+  void OnFrameRendered(const base::Closure& done);
+
+  // Used to obtain task runner references and make calls to Java methods.
+  ChromotingJniRuntime* jni_runtime_;
+
+  SoftwareVideoRenderer software_video_renderer_;
+
+  // Renderer object used to render the frames on the display thread.
+  std::unique_ptr<Renderer> renderer_;
+
+  base::WeakPtrFactory<JniVideoRenderer> weak_factory_;
+
+  DISALLOW_COPY_AND_ASSIGN(JniVideoRenderer);
 };
 
 }  // namespace remoting
+
 #endif  // REMOTING_CLIENT_JNI_JNI_VIDEO_RENDERER_H_

remoting/client/plugin/chromoting_instance.cc

@@ -633,16 +633,20 @@ void ChromotingInstance::HandleConnect(const base::DictionaryValue& data) {
 
   // Try initializing 3D video renderer.
   video_renderer_.reset(new PepperVideoRenderer3D());
-  if (!video_renderer_->Initialize(this, context_, this, &perf_tracker_))
+  video_renderer_->SetPepperContext(this, this);
+  if (!video_renderer_->Initialize(context_, &perf_tracker_)) {
     video_renderer_.reset();
+  }
 
   // If we didn't initialize 3D renderer then use the 2D renderer.
   if (!video_renderer_) {
     LOG(WARNING)
         << "Failed to initialize 3D renderer. Using 2D renderer instead.";
     video_renderer_.reset(new PepperVideoRenderer2D());
-    if (!video_renderer_->Initialize(this, context_, this, &perf_tracker_))
+    video_renderer_->SetPepperContext(this, this);
+    if (!video_renderer_->Initialize(context_, &perf_tracker_)) {
       video_renderer_.reset();
+    }
   }
 
   CHECK(video_renderer_);

remoting/client/plugin/pepper_video_renderer.h

@@ -46,12 +46,10 @@ class PepperVideoRenderer : public protocol::VideoRenderer {
         const webrtc::DesktopRegion& dirty_region) = 0;
   };
 
-  // Initializes the renderer. |instance| and |event_handler| must outlive the
-  // renderer. Returns false if the renderer cannot be initialized.
-  virtual bool Initialize(pp::Instance* instance,
-                          const ClientContext& context,
-                          EventHandler* event_handler,
-                          protocol::PerformanceTracker* perf_tracker) = 0;
+  // Sets pepper context. Must be called before Initialize(). |instance| and
+  // |event_handler| must outlive the renderer.
+  virtual void SetPepperContext(pp::Instance* instance,
+                                EventHandler* event_handler) = 0;
 
   // Must be called whenever the plugin view changes.
   virtual void OnViewChanged(const pp::View& view) = 0;

remoting/client/plugin/pepper_video_renderer_2d.cc

@@ -21,7 +21,6 @@
 #include "ppapi/cpp/size.h"
 #include "remoting/base/util.h"
 #include "remoting/client/client_context.h"
-#include "remoting/client/software_video_renderer.h"
 #include "remoting/proto/video.pb.h"
 #include "remoting/protocol/performance_tracker.h"
 #include "third_party/libyuv/include/libyuv/scale_argb.h"
@@ -55,16 +54,15 @@ class PepperDesktopFrame : public webrtc::DesktopFrame {
 }  // namespace
 
 PepperVideoRenderer2D::PepperVideoRenderer2D()
-    : callback_factory_(this),
+    : software_video_renderer_(this),
+      callback_factory_(this),
       weak_factory_(this) {}
 
 PepperVideoRenderer2D::~PepperVideoRenderer2D() {}
 
-bool PepperVideoRenderer2D::Initialize(
+void PepperVideoRenderer2D::SetPepperContext(
     pp::Instance* instance,
-    const ClientContext& context,
-    EventHandler* event_handler,
-    protocol::PerformanceTracker* perf_tracker) {
+    EventHandler* event_handler) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(!instance_);
   DCHECK(!event_handler_);
@@ -73,10 +71,6 @@ bool PepperVideoRenderer2D::Initialize(
 
   instance_ = instance;
   event_handler_ = event_handler;
-  software_video_renderer_.reset(new SoftwareVideoRenderer(
-      context.decode_task_runner(), this, perf_tracker));
-
-  return true;
 }
 
 void PepperVideoRenderer2D::OnViewChanged(const pp::View& view) {
@@ -102,23 +96,31 @@ void PepperVideoRenderer2D::EnableDebugDirtyRegion(bool enable) {
   debug_dirty_region_ = enable;
 }
 
+bool PepperVideoRenderer2D::Initialize(
+    const ClientContext& client_context,
+    protocol::PerformanceTracker* perf_tracker) {
+  DCHECK(thread_checker_.CalledOnValidThread());
+
+  return software_video_renderer_.Initialize(client_context, perf_tracker);
+}
+
 void PepperVideoRenderer2D::OnSessionConfig(
     const protocol::SessionConfig& config) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
-  software_video_renderer_->OnSessionConfig(config);
+  software_video_renderer_.OnSessionConfig(config);
 }
 
 protocol::VideoStub* PepperVideoRenderer2D::GetVideoStub() {
   DCHECK(thread_checker_.CalledOnValidThread());
 
-  return software_video_renderer_->GetVideoStub();
+  return software_video_renderer_.GetVideoStub();
 }
 
 protocol::FrameConsumer* PepperVideoRenderer2D::GetFrameConsumer() {
   DCHECK(thread_checker_.CalledOnValidThread());
 
-  return software_video_renderer_->GetFrameConsumer();
+  return software_video_renderer_.GetFrameConsumer();
 }
 
 std::unique_ptr<webrtc::DesktopFrame> PepperVideoRenderer2D::AllocateFrame(

remoting/client/plugin/pepper_video_renderer_2d.h

@@ -19,6 +19,7 @@
 #include "ppapi/cpp/view.h"
 #include "ppapi/utility/completion_callback_factory.h"
 #include "remoting/client/plugin/pepper_video_renderer.h"
+#include "remoting/client/software_video_renderer.h"
 #include "remoting/protocol/frame_consumer.h"
 #include "third_party/webrtc/modules/desktop_capture/desktop_geometry.h"
 
@@ -44,14 +45,14 @@ class PepperVideoRenderer2D : public PepperVideoRenderer,
   ~PepperVideoRenderer2D() override;
 
   // PepperVideoRenderer interface.
-  bool Initialize(pp::Instance* instance,
-                  const ClientContext& context,
-                  EventHandler* event_handler,
-                  protocol::PerformanceTracker* perf_tracker) override;
+  void SetPepperContext(pp::Instance* instance,
+                        EventHandler* event_handler) override;
   void OnViewChanged(const pp::View& view) override;
   void EnableDebugDirtyRegion(bool enable) override;
 
   // VideoRenderer interface.
+  bool Initialize(const ClientContext& client_context,
+                  protocol::PerformanceTracker* perf_tracker) override;
   void OnSessionConfig(const protocol::SessionConfig& config) override;
   protocol::VideoStub* GetVideoStub() override;
   protocol::FrameConsumer* GetFrameConsumer() override;
@@ -74,7 +75,7 @@ class PepperVideoRenderer2D : public PepperVideoRenderer,
 
   pp::Graphics2D graphics2d_;
 
-  std::unique_ptr<SoftwareVideoRenderer> software_video_renderer_;
+  SoftwareVideoRenderer software_video_renderer_;
 
   // View size in output pixels.
   webrtc::DesktopSize view_size_;

remoting/client/plugin/pepper_video_renderer_3d.cc

@@ -78,15 +78,33 @@ PepperVideoRenderer3D::~PepperVideoRenderer3D() {
     gles2_if_->DeleteProgram(graphics_.pp_resource(), shader_program_);
 }
 
-bool PepperVideoRenderer3D::Initialize(
+void PepperVideoRenderer3D::SetPepperContext(
     pp::Instance* instance,
-    const ClientContext& context,
-    EventHandler* event_handler,
-    protocol::PerformanceTracker* perf_tracker) {
+    EventHandler* event_handler) {
   DCHECK(event_handler);
   DCHECK(!event_handler_);
 
   event_handler_ = event_handler;
+  pp_instance_ = instance;
+}
+
+void PepperVideoRenderer3D::OnViewChanged(const pp::View& view) {
+  pp::Size size = view.GetRect().size();
+  float scale = view.GetDeviceScale();
+  view_size_.set(ceilf(size.width() * scale), ceilf(size.height() * scale));
+  graphics_.ResizeBuffers(view_size_.width(), view_size_.height());
+
+  force_repaint_ = true;
+  PaintIfNeeded();
+}
+
+void PepperVideoRenderer3D::EnableDebugDirtyRegion(bool enable) {
+  debug_dirty_region_ = enable;
+}
+
+bool PepperVideoRenderer3D::Initialize(
+    const ClientContext& context,
+    protocol::PerformanceTracker* perf_tracker) {
   perf_tracker_ = perf_tracker;
 
   const int32_t context_attributes[] = {
@@ -102,13 +120,13 @@ bool PepperVideoRenderer3D::Initialize(
       PP_GRAPHICS3DATTRIB_HEIGHT,         480,
       PP_GRAPHICS3DATTRIB_NONE,
   };
-  graphics_ = pp::Graphics3D(instance, context_attributes);
+  graphics_ = pp::Graphics3D(pp_instance_, context_attributes);
 
   if (graphics_.is_null()) {
     LOG(WARNING) << "Graphics3D interface is not available.";
     return false;
   }
-  if (!instance->BindGraphics(graphics_)) {
+  if (!pp_instance_->BindGraphics(graphics_)) {
     LOG(WARNING) << "Failed to bind Graphics3D.";
     return false;
   }
@@ -118,7 +136,7 @@ bool PepperVideoRenderer3D::Initialize(
       pp::Module::Get()->GetBrowserInterface(PPB_OPENGLES2_INTERFACE));
   CHECK(gles2_if_);
 
-  video_decoder_ = pp::VideoDecoder(instance);
+  video_decoder_ = pp::VideoDecoder(pp_instance_);
   if (video_decoder_.is_null()) {
     LOG(WARNING) << "VideoDecoder interface is not available.";
     return false;
@@ -147,20 +165,6 @@ bool PepperVideoRenderer3D::Initialize(
   return true;
 }
 
-void PepperVideoRenderer3D::OnViewChanged(const pp::View& view) {
-  pp::Size size = view.GetRect().size();
-  float scale = view.GetDeviceScale();
-  view_size_.set(ceilf(size.width() * scale), ceilf(size.height() * scale));
-  graphics_.ResizeBuffers(view_size_.width(), view_size_.height());
-
-  force_repaint_ = true;
-  PaintIfNeeded();
-}
-
-void PepperVideoRenderer3D::EnableDebugDirtyRegion(bool enable) {
-  debug_dirty_region_ = enable;
-}
-
 void PepperVideoRenderer3D::OnSessionConfig(
     const protocol::SessionConfig& config) {
   PP_VideoProfile video_profile = PP_VIDEOPROFILE_VP8_ANY;

remoting/client/plugin/pepper_video_renderer_3d.h

@@ -34,14 +34,14 @@ class PepperVideoRenderer3D : public PepperVideoRenderer,
   ~PepperVideoRenderer3D() override;
 
   // PepperVideoRenderer interface.
-  bool Initialize(pp::Instance* instance,
-                  const ClientContext& context,
-                  EventHandler* event_handler,
-                  protocol::PerformanceTracker* perf_tracker) override;
+  void SetPepperContext(pp::Instance* instance,
+                        EventHandler* event_handler) override;
   void OnViewChanged(const pp::View& view) override;
   void EnableDebugDirtyRegion(bool enable) override;
 
   // VideoRenderer interface.
+  bool Initialize(const ClientContext& client_context,
+                  protocol::PerformanceTracker* perf_tracker) override;
   void OnSessionConfig(const protocol::SessionConfig& config) override;
   protocol::VideoStub* GetVideoStub() override;
   protocol::FrameConsumer* GetFrameConsumer() override;
@@ -91,6 +91,7 @@ class PepperVideoRenderer3D : public PepperVideoRenderer,
   // CHECKs that the last OpenGL call has completed successfully.
   void CheckGLError();
 
+  pp::Instance* pp_instance_ = nullptr;
   EventHandler* event_handler_ = nullptr;
   protocol::PerformanceTracker* perf_tracker_ = nullptr;
 

remoting/client/software_video_renderer.cc

@@ -15,6 +15,7 @@
 #include "base/single_thread_task_runner.h"
 #include "base/task_runner_util.h"
 #include "remoting/base/util.h"
+#include "remoting/client/client_context.h"
 #include "remoting/codec/video_decoder.h"
 #include "remoting/codec/video_decoder_verbatim.h"
 #include "remoting/codec/video_decoder_vpx.h"
@@ -44,6 +45,12 @@ std::unique_ptr<webrtc::DesktopFrame> DoDecodeFrame(
 
 }  // namespace
 
+SoftwareVideoRenderer::SoftwareVideoRenderer(protocol::FrameConsumer* consumer)
+    : consumer_(consumer),
+      weak_factory_(this) {
+  thread_checker_.DetachFromThread();
+}
+
 SoftwareVideoRenderer::SoftwareVideoRenderer(
     scoped_refptr<base::SingleThreadTaskRunner> decode_task_runner,
     protocol::FrameConsumer* consumer,
@@ -58,6 +65,15 @@ SoftwareVideoRenderer::~SoftwareVideoRenderer() {
     decode_task_runner_->DeleteSoon(FROM_HERE, decoder_.release());
 }
 
+bool SoftwareVideoRenderer::Initialize(
+    const ClientContext& client_context,
+    protocol::PerformanceTracker* perf_tracker) {
+  DCHECK(thread_checker_.CalledOnValidThread());
+  decode_task_runner_ = client_context.decode_task_runner();
+  perf_tracker_ = perf_tracker;
+  return true;
+}
+
 void SoftwareVideoRenderer::OnSessionConfig(
     const protocol::SessionConfig& config) {
   DCHECK(thread_checker_.CalledOnValidThread());

remoting/client/software_video_renderer.h

@@ -40,6 +40,13 @@ class PerformanceTracker;
 class SoftwareVideoRenderer : public protocol::VideoRenderer,
                               public protocol::VideoStub {
  public:
+  // The renderer can be created on any thread but afterwards all methods must
+  // be called on the same thread.
+  SoftwareVideoRenderer(protocol::FrameConsumer* consumer);
+
+  // Deprecated constructor. TODO(yuweih): remove.
+  // Constructs the renderer and initializes it immediately. Caller should not
+  // call Initialize() after using this constructor.
   // All methods must be called on the same thread the renderer is created. The
   // |decode_task_runner_| is used to decode the video packets. |perf_tracker|
   // must outlive the renderer. |perf_tracker| may be nullptr, performance
@@ -51,6 +58,8 @@ class SoftwareVideoRenderer : public protocol::VideoRenderer,
   ~SoftwareVideoRenderer() override;
 
   // VideoRenderer interface.
+  bool Initialize(const ClientContext& client_context,
+                  protocol::PerformanceTracker* perf_tracker) override;
   void OnSessionConfig(const protocol::SessionConfig& config) override;
   protocol::VideoStub* GetVideoStub() override;
   protocol::FrameConsumer* GetFrameConsumer() override;
@@ -68,7 +77,7 @@ class SoftwareVideoRenderer : public protocol::VideoRenderer,
 
   scoped_refptr<base::SingleThreadTaskRunner> decode_task_runner_;
   protocol::FrameConsumer* consumer_;
-  protocol::PerformanceTracker* perf_tracker_;
+  protocol::PerformanceTracker* perf_tracker_ = nullptr;
 
   std::unique_ptr<VideoDecoder> decoder_;
 

remoting/protocol/fake_video_renderer.cc

@@ -66,6 +66,11 @@ FrameConsumer::PixelFormat FakeFrameConsumer::GetPixelFormat() {
 FakeVideoRenderer::FakeVideoRenderer() {}
 FakeVideoRenderer::~FakeVideoRenderer() {}
 
+bool FakeVideoRenderer::Initialize(const ClientContext& client_context,
+                                   protocol::PerformanceTracker* perf_tracker) {
+  return true;
+}
+
 void FakeVideoRenderer::OnSessionConfig(const SessionConfig& config) {}
 
 FakeVideoStub* FakeVideoRenderer::GetVideoStub() {

remoting/protocol/fake_video_renderer.h

@@ -70,6 +70,8 @@ class FakeVideoRenderer : public VideoRenderer {
   ~FakeVideoRenderer() override;
 
   // VideoRenderer interface.
+  bool Initialize(const ClientContext& client_context,
+                  protocol::PerformanceTracker* perf_tracker) override;
   void OnSessionConfig(const SessionConfig& config) override;
   FakeVideoStub* GetVideoStub() override;
   FakeFrameConsumer* GetFrameConsumer() override;

remoting/protocol/video_renderer.h

@@ -6,9 +6,13 @@
 #define REMOTING_CLIENT_VIDEO_RENDERER_H_
 
 namespace remoting {
+
+class ClientContext;
+
 namespace protocol {
 
 class FrameConsumer;
+class PerformanceTracker;
 class SessionConfig;
 class VideoStub;
 
@@ -22,6 +26,14 @@ class VideoRenderer {
  public:
   virtual ~VideoRenderer() {}
 
+  // Initializes the video renderer. This allows the renderer to be initialized
+  // after it is constructed. Returns true if initialization succeeds and false
+  // otherwise. An implementation that doesn't use this function to initialize
+  // should always return true.
+  // |perf_tracker| must outlive the renderer.
+  virtual bool Initialize(const ClientContext& client_context,
+                          protocol::PerformanceTracker* perf_tracker) = 0;
+
   // Configures the renderer with the supplied |config|. This must be called
   // exactly once before video data is supplied to the renderer.
   virtual void OnSessionConfig(const SessionConfig& config) = 0;

remoting/test/protocol_perftest.cc

@@ -149,6 +149,10 @@ class ProtocolPerfTest
   }
 
   // VideoRenderer interface.
+  bool Initialize(const ClientContext& client_context,
+                  protocol::PerformanceTracker* perf_tracker) override {
+    return true;
+  }
   void OnSessionConfig(const protocol::SessionConfig& config) override {}
   protocol::VideoStub* GetVideoStub() override { return this; }
   protocol::FrameConsumer* GetFrameConsumer() override { return this; }

remoting/test/test_video_renderer.cc

@@ -294,6 +294,11 @@ TestVideoRenderer::~TestVideoRenderer() {
   video_decode_thread_->Stop();
 }
 
+bool TestVideoRenderer::Initialize(const ClientContext& client_context,
+                                   protocol::PerformanceTracker* perf_tracker) {
+  return true;
+}
+
 void TestVideoRenderer::OnSessionConfig(const protocol::SessionConfig& config) {
   DCHECK(thread_checker_.CalledOnValidThread());
 

remoting/test/test_video_renderer.h

@@ -40,6 +40,8 @@ class TestVideoRenderer : public protocol::VideoRenderer,
   ~TestVideoRenderer() override;
 
   // VideoRenderer interface.
+  bool Initialize(const ClientContext& client_context,
+                  protocol::PerformanceTracker* perf_tracker) override;
   void OnSessionConfig(const protocol::SessionConfig& config) override;
   protocol::VideoStub* GetVideoStub() override;
   protocol::FrameConsumer* GetFrameConsumer() override;