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.
+  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_) {
+   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();
+  }
 
   // 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