[Remoting Android] DisplayUpdaterFactory cleanups

remoting/client/plugin/pepper_video_renderer_2d.cc

 // Copyright (c) 2012 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/plugin/pepper_video_renderer_2d.h"
 
 #include <stdint.h>
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/callback_helpers.h"
 #include "base/memory/ptr_util.h"
 #include "base/strings/string_util.h"
 #include "base/task_runner_util.h"
 #include "ppapi/cpp/completion_callback.h"
 #include "ppapi/cpp/image_data.h"
 #include "ppapi/cpp/instance.h"
 #include "ppapi/cpp/point.h"
 #include "ppapi/cpp/rect.h"
 #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"
 #include "third_party/webrtc/modules/desktop_capture/desktop_frame.h"
 
 namespace remoting {
 
 namespace {
 
 // DesktopFrame that wraps a supplied pp::ImageData
@@ skipping 13 matching lines @@
     return buffer_;
   }
 
  private:
   pp::ImageData buffer_;
 };
 
 }  // 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_);
   DCHECK(instance);
   DCHECK(event_handler);
 
   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) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   pp::Rect pp_size = view.GetRect();
   view_size_ = webrtc::DesktopSize(pp_size.width(), pp_size.height());
 
   // Update scale if graphics2d has been initialized.
   if (!graphics2d_.is_null() && source_size_.width() > 0) {
     graphics2d_.SetScale(static_cast<float>(view_size_.width()) /
                          source_size_.width());
 
     // Bind graphics2d_ again after changing the scale to work around
     // crbug.com/521745 .
     instance_->BindGraphics(graphics2d_);
     bool result = instance_->BindGraphics(graphics2d_);
     DCHECK(result) << "Couldn't bind the device context.";
   }
 }
 
 void PepperVideoRenderer2D::EnableDebugDirtyRegion(bool enable) {
   debug_dirty_region_ = enable;
 }
 
+bool PepperVideoRenderer2D::Initialize(
+    const ClientContext& client_context,
+    protocol::PerformanceTracker* perf_tracker) {
+  DCHECK(thread_checker_.CalledOnValidThread());
+
+  software_video_renderer_.Initialize(client_context, perf_tracker);

[Sergey Ulanov, 2016/06/29 23:02:12]

return the result.

[Yuwei, 2016/06/29 23:38:02]

Done.

+
+  return true;
+}
+
 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(
     const webrtc::DesktopSize& size) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   pp::ImageData buffer_data(instance_, PP_IMAGEDATAFORMAT_BGRA_PREMUL,
                             pp::Size(size.width(), size.height()), false);
   return base::WrapUnique(new PepperDesktopFrame(buffer_data));
 }
@@ skipping 76 matching lines @@
   flush_pending_ = false;
 
   // Call all callbacks for the frames we've just flushed.
   flushing_frames_done_callbacks_.clear();
 
   // Flush again if necessary.
   Flush();
 }
 
 }  // namespace remoting