Add video frame recording capability to Chromoting hosts.

remoting/host/remoting_me2me_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.
 //
 // This file implements a standalone host process for Me2Me.
 
 #include <string>
 
 #include "base/at_exit.h"
 #include "base/bind.h"
@@ skipping 50 matching lines @@
 #include "remoting/host/json_host_config.h"
 #include "remoting/host/logging.h"
 #include "remoting/host/me2me_desktop_environment.h"
 #include "remoting/host/pairing_registry_delegate.h"
 #include "remoting/host/policy_hack/policy_watcher.h"
 #include "remoting/host/session_manager_factory.h"
 #include "remoting/host/signaling_connector.h"
 #include "remoting/host/token_validator_factory_impl.h"
 #include "remoting/host/usage_stats_consent.h"
 #include "remoting/host/username.h"
+#include "remoting/host/video_frame_recorder_host_extension.h"
 #include "remoting/jingle_glue/network_settings.h"
 #include "remoting/jingle_glue/xmpp_signal_strategy.h"
 #include "remoting/protocol/me2me_host_authenticator_factory.h"
 #include "remoting/protocol/pairing_registry.h"
 #include "remoting/protocol/token_validator.h"
 
 #if defined(OS_POSIX)
 #include <signal.h>
 #include <sys/types.h>
 #include <unistd.h>
@@ skipping 35 matching lines @@
 const char kAuthSocknameSwitchName[] = "ssh-auth-sockname";
 #endif  // defined(OS_LINUX)
 
 // The command line switch used by the parent to request the host to signal it
 // when it is successfully started.
 const char kSignalParentSwitchName[] = "signal-parent";
 
 // Command line switch used to enable VP9 encoding.
 const char kEnableVp9SwitchName[] = "enable-vp9";
 
+// Command line switch used to enable and configure the frame-recorder.
+const char kFrameRecorderBufferKbName[] = "frame-recorder-buffer-kb";

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

Add this flag in the usage message in host_main.cc

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

Do we really need this flag? Maybe always have recorder enabled with some
sensible buffer size. It won't do anything until recording is enabled anyway.

[Wez, 2014/07/31 23:57:46]

It's not clear what a "sensible buffer size" would be; I'd prefer not to leave a
loophole whereby a client can exhaust memory resources on constrained host
systems, for example.

+
 // Value used for --host-config option to indicate that the path must be read
 // from stdin.
 const char kStdinConfigPath[] = "-";
 
 }  // namespace
 
 namespace remoting {
 
 class HostProcess
     : public ConfigWatcher::Delegate,
@@ skipping 144 matching lines @@
   scoped_ptr<ConfigWatcher> config_watcher_;
 
   std::string host_id_;
   protocol::SharedSecretHash host_secret_hash_;
   scoped_refptr<RsaKeyPair> key_pair_;
   std::string oauth_refresh_token_;
   std::string serialized_config_;
   std::string host_owner_;
   bool use_service_account_;
   bool enable_vp9_;
+  int64_t frame_recorder_buffer_size_;
 
   scoped_ptr<policy_hack::PolicyWatcher> policy_watcher_;
   std::string host_domain_;
   bool host_username_match_required_;
   bool allow_nat_traversal_;
   bool allow_relay_;
   int min_udp_port_;
   int max_udp_port_;
   std::string talkgadget_prefix_;
   bool allow_pairing_;
@@ skipping 25 matching lines @@
 
   scoped_ptr<PairingRegistry::Delegate> pairing_registry_delegate_;
 };
 
 HostProcess::HostProcess(scoped_ptr<ChromotingHostContext> context,
                          int* exit_code_out)
     : context_(context.Pass()),
       state_(HOST_INITIALIZING),
       use_service_account_(false),
       enable_vp9_(false),
+      frame_recorder_buffer_size_(0),
       host_username_match_required_(false),
       allow_nat_traversal_(true),
       allow_relay_(true),
       min_udp_port_(0),
       max_udp_port_(0),
       allow_pairing_(true),
       curtain_required_(false),
       enable_gnubby_auth_(false),
 #if defined(REMOTING_MULTI_PROCESS)
       desktop_session_connector_(NULL),
@@ skipping 473 matching lines @@
     use_service_account_ = false;
   }
 
   // Allow offering of VP9 encoding to be overridden by the command-line.
   if (CommandLine::ForCurrentProcess()->HasSwitch(kEnableVp9SwitchName)) {
     enable_vp9_ = true;
   } else {
     config->GetBoolean(kEnableVp9ConfigPath, &enable_vp9_);
   }
 
+  // Allow the command-line to override the size of the frame recorder buffer.
+  std::string frame_recorder_buffer_kb;
+  if (CommandLine::ForCurrentProcess()->HasSwitch(
+          kFrameRecorderBufferKbName)) {
+    frame_recorder_buffer_kb =
+        CommandLine::ForCurrentProcess()->GetSwitchValueASCII(
+            kFrameRecorderBufferKbName);
+  } else {
+    config->GetString(kFrameRecorderBufferKbConfigPath,
+                      &frame_recorder_buffer_kb);
+  }
+  if (!frame_recorder_buffer_kb.empty()) {
+    int buffer_kb = 0;
+    if (base::StringToInt(frame_recorder_buffer_kb, &buffer_kb)) {
+      frame_recorder_buffer_size_ = 1024LL * buffer_kb;
+    }
+  }
+
   return true;
 }
 
 void HostProcess::OnPolicyUpdate(scoped_ptr<base::DictionaryValue> policies) {
   if (!context_->network_task_runner()->BelongsToCurrentThread()) {
     context_->network_task_runner()->PostTask(FROM_HERE, base::Bind(
         &HostProcess::OnPolicyUpdate, this, base::Passed(&policies)));
     return;
   }
 
@@ skipping 360 matching lines @@
       context_->network_task_runner(),
       context_->ui_task_runner()));
 
   if (enable_vp9_) {
     scoped_ptr<protocol::CandidateSessionConfig> config =
         host_->protocol_config()->Clone();
     config->EnableVideoCodec(protocol::ChannelConfig::CODEC_VP9);
     host_->set_protocol_config(config.Pass());
   }
 
+  if (frame_recorder_buffer_size_ > 0) {
+    scoped_ptr<VideoFrameRecorderHostExtension> frame_recorder_extension(
+        new VideoFrameRecorderHostExtension());
+    frame_recorder_extension->SetMaxContentBytes(frame_recorder_buffer_size_);
+    host_->SetEnableVideoFrameRecording(true);
+    host_->AddExtension(frame_recorder_extension.PassAs<HostExtension>());
+  }
+
   // TODO(simonmorris): Get the maximum session duration from a policy.
 #if defined(OS_LINUX)
   host_->SetMaximumSessionDuration(base::TimeDelta::FromHours(20));
 #endif
 
   heartbeat_sender_.reset(new HeartbeatSender(
       this, host_id_, signal_strategy_.get(), key_pair_,
       directory_bot_jid_));
 
   host_status_sender_.reset(new HostStatusSender(
       host_id_, signal_strategy_.get(), key_pair_, directory_bot_jid_));
 
   host_change_notification_listener_.reset(new HostChangeNotificationListener(
       this, host_id_, signal_strategy_.get(), directory_bot_jid_));
 
   host_status_logger_.reset(
       new HostStatusLogger(host_->AsWeakPtr(), ServerLogEntry::ME2ME,
                            signal_strategy_.get(), directory_bot_jid_));
 
-  // Set up repoting the host status notifications.
+  // Set up reporting the host status notifications.
 #if defined(REMOTING_MULTI_PROCESS)
   host_event_logger_.reset(
       new IpcHostEventLogger(host_->AsWeakPtr(), daemon_channel_.get()));
 #else  // !defined(REMOTING_MULTI_PROCESS)
   host_event_logger_ =
       HostEventLogger::Create(host_->AsWeakPtr(), kApplicationName);
 #endif  // !defined(REMOTING_MULTI_PROCESS)
 
   host_->SetEnableCurtaining(curtain_required_);
   host_->Start(host_owner_);
@@ skipping 137 matching lines @@
   return exit_code;
 }
 
 }  // namespace remoting
 
 #if !defined(OS_WIN)
 int main(int argc, char** argv) {
   return remoting::HostMain(argc, argv);
 }
 #endif  // !defined(OS_WIN)