Implement a dummy host to do capturing and analysis only.

remoting/protocol/fake_connection_to_client.cc

 // Copyright 2015 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/protocol/fake_connection_to_client.h"
 
 #include <utility>
 
+#include "remoting/codec/video_encoder.h"
 #include "remoting/protocol/session.h"
+#include "remoting/protocol/video_frame_pump.h"
 #include "third_party/webrtc/modules/desktop_capture/desktop_capturer.h"
 
 namespace remoting {
 namespace protocol {
 
 FakeVideoStream::FakeVideoStream() : weak_factory_(this) {}
 FakeVideoStream::~FakeVideoStream() {}
 
 void FakeVideoStream::Pause(bool pause) {}
 
@@ skipping 15 matching lines @@
     : session_(std::move(session)) {}
 
 FakeConnectionToClient::~FakeConnectionToClient() {}
 
 void FakeConnectionToClient::SetEventHandler(EventHandler* event_handler) {
   event_handler_ = event_handler;
 }
 
 std::unique_ptr<VideoStream> FakeConnectionToClient::StartVideoStream(
     std::unique_ptr<webrtc::DesktopCapturer> desktop_capturer) {
+  if (video_stub_ && video_encode_task_runner_) {

[joedow, 2016/05/04 16:40:44]

What would it mean for a caller to set one of these and not the other?  Should
that be considered an error (to let the caller know the object isn't
initialized) or should the init methods be changed so they require both to be
set?  Or should we add a DCHECK to make sure they are bot set or both null?

[Hzj_jie, 2016/05/04 19:18:03]

Oh, we have discussed this in an early iteration, since this is a fake object,
there may be some other combinations of the parameters for other scenarios.

[joedow, 2016/05/04 22:58:49]

OK, I'd like to prevent a caller from partially initializing an instance of this
class but this is a minor nit.

+    std::unique_ptr<VideoEncoder> video_encoder =
+        VideoEncoder::Create(session_->config());
+
+    std::unique_ptr<protocol::VideoFramePump> pump(
+        new protocol::VideoFramePump(video_encode_task_runner_,
+                                     std::move(desktop_capturer),
+                                     std::move(video_encoder),
+                                     video_stub_));
+    video_feedback_stub_ = pump->video_feedback_stub();
+    return std::move(pump);
+  }
+
   std::unique_ptr<FakeVideoStream> result(new FakeVideoStream());
   last_video_stream_ = result->GetWeakPtr();
   return std::move(result);
 }
 
 AudioStub* FakeConnectionToClient::audio_stub() {
   return audio_stub_;
 }
 
 ClientStub* FakeConnectionToClient::client_stub() {
@@ skipping 22 matching lines @@
 void FakeConnectionToClient::set_host_stub(HostStub* host_stub) {
   host_stub_ = host_stub;
 }
 
 void FakeConnectionToClient::set_input_stub(InputStub* input_stub) {
   input_stub_ = input_stub;
 }
 
 }  // namespace protocol
 }  // namespace remoting