Add video frame recording capability to Chromoting hosts.

remoting/host/chromoting_host.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/host/chromoting_host.h"
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/command_line.h"
 #include "base/message_loop/message_loop_proxy.h"
 #include "build/build_config.h"
 #include "jingle/glue/thread_wrapper.h"
 #include "remoting/base/constants.h"
 #include "remoting/base/logging.h"
 #include "remoting/host/chromoting_host_context.h"
 #include "remoting/host/desktop_environment.h"
 #include "remoting/host/host_config.h"
 #include "remoting/host/input_injector.h"
+#include "remoting/host/video_frame_recorder.h"
 #include "remoting/protocol/connection_to_client.h"
 #include "remoting/protocol/client_stub.h"
 #include "remoting/protocol/host_stub.h"
 #include "remoting/protocol/input_stub.h"
 #include "remoting/protocol/session_config.h"
 
 using remoting::protocol::ConnectionToClient;
 using remoting::protocol::InputStub;
 
 namespace remoting {
@@ skipping 46 matching lines @@
       video_encode_task_runner_(video_encode_task_runner),
       network_task_runner_(network_task_runner),
       ui_task_runner_(ui_task_runner),
       signal_strategy_(signal_strategy),
       started_(false),
       protocol_config_(protocol::CandidateSessionConfig::CreateDefault()),
       login_backoff_(&kDefaultBackoffPolicy),
       authenticating_client_(false),
       reject_authenticating_client_(false),
       enable_curtaining_(false),
+      enable_video_frame_recording_(false),
       weak_factory_(this) {
   DCHECK(network_task_runner_->BelongsToCurrentThread());
   DCHECK(signal_strategy);
 
   jingle_glue::JingleThreadWrapper::EnsureForCurrentMessageLoop();
 
   if (!desktop_environment_factory_->SupportsAudioCapture()) {
     protocol_config_->DisableAudioChannel();
   }
 }
@@ skipping 68 matching lines @@
   // curtained sessions.
   if (enable_curtaining_)
     DisconnectAllClients();
 }
 
 void ChromotingHost::SetMaximumSessionDuration(
     const base::TimeDelta& max_session_duration) {
   max_session_duration_ = max_session_duration;
 }
 
+void ChromotingHost::SetEnableVideoFrameRecording(bool enable) {
+  DCHECK(network_task_runner_->BelongsToCurrentThread());
+
+  if (enable_video_frame_recording_ == enable)
+    return;
+
+  enable_video_frame_recording_ = enable;
+
+  // Disconnect existing clients if recording is being disabled, in case
+  // one of them is using it.
+  if (!enable) {

[Sergey Ulanov, 2014/07/11 18:38:03]

nit: remove {}

+    DisconnectAllClients();
+  }
+}
+
 ////////////////////////////////////////////////////////////////////////////
 // protocol::ClientSession::EventHandler implementation.
 void ChromotingHost::OnSessionAuthenticating(ClientSession* client) {
   // We treat each incoming connection as a failure to authenticate,
   // and clear the backoff when a connection successfully
   // authenticates. This allows the backoff to protect from parallel
   // connection attempts as well as sequential ones.
   if (login_backoff_.ShouldRejectRequest()) {
     LOG(WARNING) << "Disconnecting client " << client->client_jid() << " due to"
                     " an overload of failed login attempts.";
@@ skipping 139 matching lines @@
       input_task_runner_,
       video_capture_task_runner_,
       video_encode_task_runner_,
       network_task_runner_,
       ui_task_runner_,
       connection.Pass(),
       desktop_environment_factory_,
       max_session_duration_,
       pairing_registry_);
 
+  // Set a video frame recorder if recording is enabled.
+  if (enable_video_frame_recording_) {
+    client->set_video_frame_recorder(
+        scoped_ptr<VideoFrameRecorder>(new VideoFrameRecorder()));
+  }
+
   // Registers capabilities provided by host extensions.
   for (HostExtensionList::iterator extension = extensions_.begin();
        extension != extensions_.end(); ++extension) {
     client->AddHostCapabilities((*extension)->GetCapabilities());
   }
 
   clients_.push_back(client);
 }
 
 void ChromotingHost::set_protocol_config(
     scoped_ptr<protocol::CandidateSessionConfig> config) {
   DCHECK(CalledOnValidThread());
   DCHECK(config.get());
   DCHECK(!started_);
   protocol_config_ = config.Pass();
 }
 
 void ChromotingHost::DisconnectAllClients() {
   DCHECK(CalledOnValidThread());
 
   while (!clients_.empty()) {
     size_t size = clients_.size();
     clients_.front()->DisconnectSession();
     CHECK_EQ(clients_.size(), size - 1);
   }
 }
 
 }  // namespace remoting