Add enable_vp9 option to host config.

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 106 matching lines @@
 
 // The command line switch used to pass name of the unix domain socket used to
 // listen for gnubby requests.
 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";
+
 // 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 143 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_;
 
   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 24 matching lines @@
   bool signal_parent_;
 
   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),
       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 465 matching lines @@
   }
 
   if (config->GetString(kHostOwnerConfigPath, &host_owner_)) {
     // Service account configs have a host_owner, different from the xmpp_login.
     use_service_account_ = true;
   } else {
     // User credential configs only have an xmpp_login, which is also the owner.
     host_owner_ = xmpp_server_config_.username;
     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_);
+  }
+
   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 354 matching lines @@
       desktop_environment_factory_.get(),
       CreateHostSessionManager(signal_strategy_.get(), network_settings,
                                context_->url_request_context_getter()),
       context_->audio_task_runner(),
       context_->input_task_runner(),
       context_->video_capture_task_runner(),
       context_->video_encode_task_runner(),
       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());
+  }
+
   // 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(
@@ skipping 157 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)