Preparations for Cast Host Extension

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 21 matching lines @@
 #include "net/socket/ssl_server_socket.h"
 #include "net/url_request/url_fetcher.h"
 #include "remoting/base/auto_thread_task_runner.h"
 #include "remoting/base/breakpad.h"
 #include "remoting/base/constants.h"
 #include "remoting/base/logging.h"
 #include "remoting/base/rsa_key_pair.h"
 #include "remoting/base/service_urls.h"
 #include "remoting/base/util.h"
 #include "remoting/host/branding.h"
+// #include "remoting/host/cast_extension.h"
 #include "remoting/host/chromoting_host.h"
 #include "remoting/host/chromoting_host_context.h"
 #include "remoting/host/chromoting_messages.h"
 #include "remoting/host/config_file_watcher.h"
 #include "remoting/host/config_watcher.h"
 #include "remoting/host/desktop_environment.h"
 #include "remoting/host/desktop_session_connector.h"
 #include "remoting/host/dns_blackhole_checker.h"
 #include "remoting/host/heartbeat_sender.h"
 #include "remoting/host/host_change_notification_listener.h"
@@ skipping 55 matching lines @@
 const char kApplicationName[] = "chromoting";
 
 #if defined(OS_LINUX)
 // The command line switch used to pass name of the pipe to capture audio on
 // linux.
 const char kAudioPipeSwitchName[] = "audio-pipe-name";
 
 // 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";
+
+// The command line switch used to enable casting in linux.
+const char kEnableCastSwitchName[] = "enable-cast";
+
 #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
@@ skipping 153 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_;
+  bool enable_cast_;
 
   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),
+      enable_cast_(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 94 matching lines @@
   if (!xmpp_server_valid) {
     LOG(ERROR) << "Invalid XMPP server: " <<
         service_urls->xmpp_server_address();
     return false;
   }
   xmpp_server_config_.use_tls = service_urls->xmpp_server_use_tls();
   directory_bot_jid_ = service_urls->directory_bot_jid();
 
   signal_parent_ = cmd_line->HasSwitch(kSignalParentSwitchName);
 
+#if defined(OS_LINUX)
+  enable_cast_ = cmd_line->HasSwitch(kEnableCastSwitchName);
+#endif  // !defined(OS_LINUX)
+
   return true;
 }
 
 void HostProcess::OnConfigUpdated(
     const std::string& serialized_config) {
   if (!context_->network_task_runner()->BelongsToCurrentThread()) {
     context_->network_task_runner()->PostTask(FROM_HERE,
         base::Bind(&HostProcess::OnConfigUpdated, this, serialized_config));
     return;
   }
@@ skipping 742 matching lines @@
   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));
+
+  // Enable Cast if specified on the command-line.
+  // TODO(aiguha): The way the enable_cast flag is propagated through to the
+  // ChromotingHost and ClientSession could be made cleaner.
+  if (enable_cast_) {
+    LOG(INFO) << "Cast Enabled.";
+    // scoped_ptr<HostExtension> extension(new CastExtension(
+    //    network_settings, context_->url_request_context_getter()));
+    // host_->AddExtension(extension.Pass());

[Wez, 2014/07/17 22:56:37]

You shouldn't need to do this; you can land the CLs as:

1. Add the necessary hooks into the Chromoting Host.
2. Add the CastExtension.
3. Use the CastExtension in the Me2Me host.

So these changes belong in the final CL, not this base CL.

[aiguha, 2014/07/18 21:30:37]

Done.

+    host_->set_enable_cast(enable_cast_);

[Wez, 2014/07/17 22:56:37]

As implemented this CL causes the host to disable Chromoting video entirely if
the EnableCast switch is provided - how can that work without the extension to
negotiate Cast output?

+  }

[aiguha, 2014/07/17 17:51:03]

Lines 1228-1230 are commented out only so I could break the CLs down. They are
very much needed and used. This is the one of the only points of contact between
the existing code and the CastExtension code.

+
 #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(
@@ skipping 154 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)