Fix WebRTC transport to use single offer-answer exchange instead of two.

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 <utility>
 
 #include "base/command_line.h"
@@ skipping 61 matching lines @@
       desktop_environment_factory_(desktop_environment_factory),
       input_tracker_(&host_input_filter_),
       remote_input_filter_(&input_tracker_),
       mouse_clamping_filter_(&remote_input_filter_),
       disable_input_filter_(&mouse_clamping_filter_),
       disable_clipboard_filter_(clipboard_echo_filter_.host_filter()),
       client_clipboard_factory_(clipboard_echo_filter_.client_filter()),
       max_duration_(max_duration),
       audio_task_runner_(audio_task_runner),
       pairing_registry_(pairing_registry),
-      is_authenticated_(false),
-      pause_video_(false),
-      lossless_video_encode_(false),
       // Note that |lossless_video_color_| defaults to true, but actually only
       // controls VP9 video stream color quality.
       lossless_video_color_(!base::CommandLine::ForCurrentProcess()->HasSwitch(
           kDisableI444SwitchName)),
       weak_factory_(this) {
   connection_->SetEventHandler(this);
 
   // Create a manager for the configured extensions, if any.
   extension_manager_.reset(new HostExtensionSessionManager(extensions, this));
 
@@ skipping 95 matching lines @@
   client_capabilities_ = make_scoped_ptr(new std::string());
   if (capabilities.has_capabilities())
     *client_capabilities_ = capabilities.capabilities();
   capabilities_ = IntersectCapabilities(*client_capabilities_,
                                         host_capabilities_);
   extension_manager_->OnNegotiatedCapabilities(
       connection_->client_stub(), capabilities_);
 
   VLOG(1) << "Client capabilities: " << *client_capabilities_;
 
-  // Calculate the set of capabilities enabled by both client and host and
-  // pass it to the desktop environment if it is available.
   desktop_environment_->SetCapabilities(capabilities_);
 }
 
 void ClientSession::RequestPairing(
     const protocol::PairingRequest& pairing_request) {
   if (pairing_registry_.get() && pairing_request.has_client_name()) {
     protocol::PairingRegistry::Pairing pairing =
         pairing_registry_->CreatePairing(pairing_request.client_name());
     protocol::PairingResponse pairing_response;
     pairing_response.set_client_id(pairing.client_id());
@@ skipping 76 matching lines @@
   // Connect the host input stubs.
   connection_->set_input_stub(&disable_input_filter_);
   host_input_filter_.set_input_stub(input_injector_.get());
 
   // Connect the clipboard stubs.
   connection_->set_clipboard_stub(&disable_clipboard_filter_);
   clipboard_echo_filter_.set_host_stub(input_injector_.get());
   clipboard_echo_filter_.set_client_stub(connection_->client_stub());
 }
 
+void ClientSession::CreateVideoStreams(
+    protocol::ConnectionToClient* connection) {
+  DCHECK(CalledOnValidThread());
+  DCHECK_EQ(connection_.get(), connection);
+
+  // Create a VideoStream to pump frames from the capturer to the client.
+  video_stream_ = connection_->StartVideoStream(
+      desktop_environment_->CreateVideoCapturer());
+
+  video_stream_->SetSizeCallback(
+      base::Bind(&ClientSession::OnScreenSizeChanged, base::Unretained(this)));
+
+  // Apply video-control parameters to the new stream.
+  video_stream_->SetLosslessEncode(lossless_video_encode_);
+  video_stream_->SetLosslessColor(lossless_video_color_);
+
+  // Pause capturing if necessary.
+  video_stream_->Pause(pause_video_);
+}
+
 void ClientSession::OnConnectionChannelsConnected(
     protocol::ConnectionToClient* connection) {
   DCHECK(CalledOnValidThread());
   DCHECK_EQ(connection_.get(), connection);
 
+  DCHECK(!channels_connected_);
+  channels_connected_ = true;
+
   // Negotiate capabilities with the client.
   VLOG(1) << "Host capabilities: " << host_capabilities_;
   protocol::Capabilities capabilities;
   capabilities.set_capabilities(host_capabilities_);
   connection_->client_stub()->SetCapabilities(capabilities);
 
   // Start the event executor.
   input_injector_->Start(CreateClipboardProxy());
   SetDisableInputs(false);
 
   // Create MouseShapePump to send mouse cursor shape.
   mouse_shape_pump_.reset(
       new MouseShapePump(desktop_environment_->CreateMouseCursorMonitor(),
                          connection_->client_stub()));
 
-  // Create a VideoStream to pump frames from the capturer to the client.
-  video_stream_ = connection_->StartVideoStream(
-      desktop_environment_->CreateVideoCapturer());
-
-  video_stream_->SetSizeCallback(
-      base::Bind(&ClientSession::OnScreenSizeChanged, base::Unretained(this)));
-
-  // Apply video-control parameters to the new stream.
-  video_stream_->SetLosslessEncode(lossless_video_encode_);
-  video_stream_->SetLosslessColor(lossless_video_color_);
-
-  // Pause capturing if necessary.
-  video_stream_->Pause(pause_video_);
-
   // Create an AudioPump 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_pump_.reset(new AudioPump(
         audio_task_runner_, desktop_environment_->CreateAudioCapturer(),
         std::move(audio_encoder), connection_->audio_stub()));
   }
 
+  if (pending_video_layout_message_) {
+    connection_->client_stub()->SetVideoLayout(*pending_video_layout_message_);
+    pending_video_layout_message_.reset();
+  }
+
   // Notify the event handler that all our channels are now connected.
   event_handler_->OnSessionChannelsConnected(this);
 }
 
 void ClientSession::OnConnectionClosed(
     protocol::ConnectionToClient* connection,
     protocol::ErrorCode error) {
   DCHECK(CalledOnValidThread());
   DCHECK_EQ(connection_.get(), connection);
 
@@ skipping 90 matching lines @@
   if (connection_->session()->config().protocol() ==
       protocol::SessionConfig::Protocol::WEBRTC) {
     protocol::VideoLayout layout;
     protocol::VideoTrackLayout* video_track = layout.add_video_track();
     video_track->set_position_x(0);
     video_track->set_position_y(0);
     video_track->set_width(size.width() * kDefaultDpi / dpi.x());
     video_track->set_height(size.height() * kDefaultDpi / dpi.y());
     video_track->set_x_dpi(dpi.x());
     video_track->set_y_dpi(dpi.y());
-    connection_->client_stub()->SetVideoLayout(layout);
+
+    // VideoLayout can be sent only after the control channel is connected. This
+    // is necessary for the case in the future.

[Jamie, 2016/04/05 21:46:35]

I don't understand this second sentence. Are you saying that a future update
will make use of the VideoLayout message or that a future update will restrict
it to be sent only when the control channel is connected? Either way, I don't
think you need the second sentence, but feel free to clarify if you meant
something else.

[Sergey Ulanov, 2016/04/06 21:23:50]

I don't understand it either :-/. Removed.

+    if (channels_connected_) {
+      connection_->client_stub()->SetVideoLayout(layout);
+    } else {
+      pending_video_layout_message_.reset(new protocol::VideoLayout(layout));
+    }
   }
 }
 
 }  // namespace remoting