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 179 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_);
+
+  if (pending_video_layout_message_) {
+    connection_->client_stub()->SetVideoLayout(*pending_video_layout_message_);
+    pending_video_layout_message_.reset();
+  }
 }
 
 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());
     pairing_response.set_shared_secret(pairing.shared_secret());
@@ skipping 75 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::OnCreateVideoStreams(
+    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);
 
   // 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()));
   }
 
   // Notify the event handler that all our channels are now connected.
@@ skipping 99 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 capabilities negotiation has finished.
+    if (client_capabilities_) {
+      connection_->client_stub()->SetVideoLayout(layout);
+    } else {
+      pending_video_layout_message_.reset(new protocol::VideoLayout(layout));
+    }
   }
 }
 
 }  // namespace remoting