[Remoting Android] DisplayUpdaterFactory cleanups

remoting/client/software_video_renderer.cc

 // Copyright 2014 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/software_video_renderer.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/callback_helpers.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/memory/ptr_util.h"
 #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"
 #include "remoting/proto/video.pb.h"
 #include "remoting/protocol/frame_consumer.h"
 #include "remoting/protocol/frame_stats.h"
 #include "remoting/protocol/performance_tracker.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"
 
 using remoting::protocol::ChannelConfig;
 using remoting::protocol::SessionConfig;
 
 namespace remoting {
 
 namespace {
 
 std::unique_ptr<webrtc::DesktopFrame> DoDecodeFrame(
     VideoDecoder* decoder,
     std::unique_ptr<VideoPacket> packet,
     std::unique_ptr<webrtc::DesktopFrame> frame) {
   if (!decoder->DecodePacket(*packet, frame.get()))
     frame.reset();
   return frame;
 }
 
 }  // namespace
 
+SoftwareVideoRenderer::SoftwareVideoRenderer(protocol::FrameConsumer* consumer)
+    : consumer_(consumer),
+      weak_factory_(this) {
+  thread_checker_.DetachFromThread();

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

Why do you need this? 

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

I think after adding Initialize, the renderer can be created on a different
thread?

+}
+
 SoftwareVideoRenderer::SoftwareVideoRenderer(
     scoped_refptr<base::SingleThreadTaskRunner> decode_task_runner,
     protocol::FrameConsumer* consumer,
     protocol::PerformanceTracker* perf_tracker)
     : decode_task_runner_(decode_task_runner),
       consumer_(consumer),
       perf_tracker_(perf_tracker),
       weak_factory_(this) {}
 
 SoftwareVideoRenderer::~SoftwareVideoRenderer() {
   if (decoder_)
     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());
 
   // Initialize decoder based on the selected codec.
   ChannelConfig::Codec codec = config.video_config().codec;
   if (codec == ChannelConfig::CODEC_VERBATIM) {
     decoder_.reset(new VideoDecoderVerbatim());
   } else if (codec == ChannelConfig::CODEC_VP8) {
     decoder_ = VideoDecoderVpx::CreateForVP8();
@@ skipping 96 matching lines @@
 
   stats->time_rendered = base::TimeTicks::Now();
   if (perf_tracker_)
     perf_tracker_->RecordVideoFrameStats(*stats);
 
   if (!done.is_null())
     done.Run();
 }
 
 }  // namespace remoting