Preparations for Cast Host Extension

remoting/host/client_session.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/client_session.h"
 
 #include <algorithm>
 
 #include "base/message_loop/message_loop_proxy.h"
 #include "remoting/base/capabilities.h"
@@ skipping 49 matching lines @@
       auth_input_filter_(&disable_input_filter_),
       auth_clipboard_filter_(&disable_clipboard_filter_),
       client_clipboard_factory_(clipboard_echo_filter_.client_filter()),
       max_duration_(max_duration),
       audio_task_runner_(audio_task_runner),
       input_task_runner_(input_task_runner),
       video_capture_task_runner_(video_capture_task_runner),
       video_encode_task_runner_(video_encode_task_runner),
       network_task_runner_(network_task_runner),
       ui_task_runner_(ui_task_runner),
-      pairing_registry_(pairing_registry) {
+      pairing_registry_(pairing_registry),
+      enable_cast_(false) {
   connection_->SetEventHandler(this);
 
   // TODO(sergeyu): Currently ConnectionToClient expects stubs to be
   // set before channels are connected. Make it possible to set stubs
   // later and set them only when connection is authenticated.
   connection_->set_clipboard_stub(&auth_clipboard_filter_);
   connection_->set_host_stub(this);
   connection_->set_input_stub(&auth_input_filter_);
 
   // |auth_*_filter_|'s states reflect whether the session is authenticated.
@@ skipping 60 matching lines @@
       webrtc::DesktopSize(resolution.dips_width(), resolution.dips_height()),
       webrtc::DesktopVector(kDefaultDPI, kDefaultDPI));
 
   // Try to match the client's resolution.
   screen_controls_->SetScreenResolution(client_resolution);
 }
 
 void ClientSession::ControlVideo(const protocol::VideoControl& video_control) {
   DCHECK(CalledOnValidThread());
 
+  // If cast is enabled, do nothing.

[Sergey Ulanov, 2014/07/17 19:00:43]

This doesn't look right. if enable_cast_ is true it doesn't mean that the host
is always casting. I think it should indicate that the host supports casting
when the client supports it and has it enabled.

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

My understanding is that |enable_cast_| means "Output video to Cast, don't
output video to the Chromoting client at all" - if |enable_cast_| is true then
we don't even create the VideoScheduler, below, it seems.

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

Thanks. Both of your comments helped me catch a bad assumption I was making,
namely that if the flag was passed to the host then we're definitely casting. It
should really mean, as Sergey said, that the host supports it and can switch to
it if the client asks.

I've rewired some things and now, the ClientSession uses default video unless
the client requests cast mode. The switching is now at a per-session basis. Wez
and I discussed that this would be good enough for now. Sergey?

+  if (enable_cast_) {
+    return;
+  }
+
   if (video_control.has_enable()) {
     VLOG(1) << "Received VideoControl (enable="
             << video_control.enable() << ")";
     video_scheduler_->Pause(!video_control.enable());
   }
   if (video_control.has_lossless_encode()) {
     VLOG(1) << "Received VideoControl (lossless_encode="
             << video_control.lossless_encode() << ")";
     video_scheduler_->SetLosslessEncode(video_control.lossless_encode());
   }
@@ skipping 142 matching lines @@
 
     desktop_environment_->SetCapabilities(*client_capabilities_);
   }
 
   // Create the object that controls the screen resolution.
   screen_controls_ = desktop_environment_->CreateScreenControls();
 
   // Create the event executor.
   input_injector_ = desktop_environment_->CreateInputInjector();
 
+  // Create the screen capturer.
+  // TODO(aiguha): Implement dynamic sharing of the screen capturer between
+  // VideoScheduler and the CastExtension/CastVideoCapturer.
+  screen_capturer_ = desktop_environment_->CreateVideoCapturer();
+
   // Connect the host clipboard and input stubs.
   host_input_filter_.set_input_stub(input_injector_.get());
   clipboard_echo_filter_.set_host_stub(input_injector_.get());
 
   // Create a VideoEncoder based on the session's video channel configuration.
   scoped_ptr<VideoEncoder> video_encoder =
       CreateVideoEncoder(connection_->session()->config());
 
   // Create a VideoScheduler to pump frames from the capturer to the client.
-  video_scheduler_ = new VideoScheduler(
+  // If cast mode is enabled, do not create it since screen capturer sharing
+  // has not yet been implemented.
+  if (!enable_cast_) {

[Sergey Ulanov, 2014/07/17 19:00:43]

Same as above - you still want VideoScheduler to work if the client doesn't
support casting or has it disabled.

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

Done.

+    video_scheduler_ = new VideoScheduler(
       video_capture_task_runner_,
       video_encode_task_runner_,
       network_task_runner_,
-      desktop_environment_->CreateVideoCapturer(),
+      screen_capturer_.Pass(),
       video_encoder.Pass(),
       connection_->client_stub(),
       &mouse_clamping_filter_);
-
+  }
   // Create an AudioScheduler if audio is enabled, to pump audio samples.
   if (connection_->session()->config().is_audio_enabled()) {
     scoped_ptr<AudioEncoder> audio_encoder =
         CreateAudioEncoder(connection_->session()->config());
     audio_scheduler_ = new AudioScheduler(
         audio_task_runner_,
         network_task_runner_,
         desktop_environment_->CreateAudioCapturer(),
         audio_encoder.Pass(),
         connection_->audio_stub());
@@ skipping 15 matching lines @@
 
     protocol::Capabilities capabilities;
     capabilities.set_capabilities(host_capabilities_);
     connection_->client_stub()->SetCapabilities(capabilities);
   }
 
   // Start the event executor.
   input_injector_->Start(CreateClipboardProxy());
   SetDisableInputs(false);
 
-  // Start capturing the screen.
-  video_scheduler_->Start();
+  // Start capturing the screen, if cast is not enabled.
+  if (!enable_cast_) {
+    video_scheduler_->Start();

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

nit: Suggest "if (video_scheduler_)" instead

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

As discussed above, this is now (as originally) always started.

+  }
 
   // Start recording audio.
   if (connection_->session()->config().is_audio_enabled())
     audio_scheduler_->Start();
 
   // Notify the event handler that all our channels are now connected.
   event_handler_->OnSessionChannelsConnected(this);
 }
 
 void ClientSession::OnConnectionClosed(
@@ skipping 128 matching lines @@
     return scoped_ptr<AudioEncoder>(new AudioEncoderVerbatim());
   } else if (audio_config.codec == protocol::ChannelConfig::CODEC_OPUS) {
     return scoped_ptr<AudioEncoder>(new AudioEncoderOpus());
   }
 
   NOTREACHED();
   return scoped_ptr<AudioEncoder>();
 }
 
 }  // namespace remoting