Ensure that connection can be closed in response to a data message.

remoting/protocol/webrtc_transport.cc

 // Copyright 2015 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/protocol/webrtc_transport.h"
 
 #include <string>
 #include <utility>
 #include <vector>
 
@@ skipping 117 matching lines @@
   explicit SetSessionDescriptionObserver(const ResultCallback& result_callback)
       : result_callback_(result_callback) {}
   ~SetSessionDescriptionObserver() override {}
 
  private:
   ResultCallback result_callback_;
 
   DISALLOW_COPY_AND_ASSIGN(SetSessionDescriptionObserver);
 };
 
+}  // namespace
 
-}  // namespace
+class WebrtcTransport::PeerConnectionWrapper
+    : public webrtc::PeerConnectionObserver {
+ public:
+  PeerConnectionWrapper(
+      rtc::Thread* worker_thread,
+      std::unique_ptr<cricket::WebRtcVideoEncoderFactory> encoder_factory,
+      std::unique_ptr<cricket::PortAllocator> port_allocator,
+      base::WeakPtr<WebrtcTransport> transport)
+      : transport_(transport) {
+    peer_connection_factory_ = webrtc::CreatePeerConnectionFactory(
+        worker_thread, rtc::Thread::Current(), &fake_audio_device_module_,
+        encoder_factory.release(), nullptr);
+
+    webrtc::FakeConstraints constraints;
+    constraints.AddMandatory(webrtc::MediaConstraintsInterface::kEnableDtlsSrtp,
+                             webrtc::MediaConstraintsInterface::kValueTrue);
+    peer_connection_ = peer_connection_factory_->CreatePeerConnection(
+        webrtc::PeerConnectionInterface::RTCConfiguration(), &constraints,
+        std::move(port_allocator), nullptr, this);
+  }
+  virtual ~PeerConnectionWrapper() { peer_connection_->Close(); }
+
+  webrtc::PeerConnectionInterface* peer_connection() {
+    return peer_connection_.get();
+  }
+
+  webrtc::PeerConnectionFactoryInterface* peer_connection_factory() {
+    return peer_connection_factory_.get();
+  }
+
+  // webrtc::PeerConnectionObserver interface.
+  void OnSignalingChange(
+      webrtc::PeerConnectionInterface::SignalingState new_state) override {
+    if (transport_)
+      transport_->OnSignalingChange(new_state);
+  }
+  void OnAddStream(
+      rtc::scoped_refptr<webrtc::MediaStreamInterface> stream) override {
+    if (transport_)
+      transport_->OnAddStream(stream);
+  }
+  void OnRemoveStream(
+      rtc::scoped_refptr<webrtc::MediaStreamInterface> stream) override {
+    if (transport_)
+      transport_->OnRemoveStream(stream);
+  }
+  void OnDataChannel(
+      rtc::scoped_refptr<webrtc::DataChannelInterface> data_channel) override {
+    if (transport_)
+      transport_->OnDataChannel(data_channel);
+  }
+  void OnRenegotiationNeeded() override {
+    if (transport_)
+      transport_->OnRenegotiationNeeded();
+  }
+  void OnIceConnectionChange(
+      webrtc::PeerConnectionInterface::IceConnectionState new_state) override {
+    if (transport_)
+      transport_->OnIceConnectionChange(new_state);
+  }
+  void OnIceGatheringChange(
+      webrtc::PeerConnectionInterface::IceGatheringState new_state) override {
+    if (transport_)
+      transport_->OnIceGatheringChange(new_state);
+  }
+  void OnIceCandidate(const webrtc::IceCandidateInterface* candidate) override {
+    if (transport_)
+      transport_->OnIceCandidate(candidate);
+  }
+
+ private:
+  webrtc::FakeAudioDeviceModule fake_audio_device_module_;
+  scoped_refptr<webrtc::PeerConnectionFactoryInterface>
+      peer_connection_factory_;
+  scoped_refptr<webrtc::PeerConnectionInterface> peer_connection_;
+
+  base::WeakPtr<WebrtcTransport> transport_;
+
+  DISALLOW_COPY_AND_ASSIGN(PeerConnectionWrapper);
+};
 
 WebrtcTransport::WebrtcTransport(
     rtc::Thread* worker_thread,
     scoped_refptr<TransportContext> transport_context,
     EventHandler* event_handler)
     : worker_thread_(worker_thread),
       transport_context_(transport_context),
       event_handler_(event_handler),
       handshake_hmac_(crypto::HMAC::SHA256),
       weak_factory_(this) {
   transport_context_->set_relay_mode(TransportContext::RelayMode::TURN);
 }
 
-WebrtcTransport::~WebrtcTransport() {}
+WebrtcTransport::~WebrtcTransport() {
+  Close(OK);
+}
+
+webrtc::PeerConnectionInterface* WebrtcTransport::peer_connection() {
+  return peer_connection_wrapper_ ? peer_connection_wrapper_->peer_connection()
+                                  : nullptr;
+}
+
+webrtc::PeerConnectionFactoryInterface*
+WebrtcTransport::peer_connection_factory() {
+  return peer_connection_wrapper_
+             ? peer_connection_wrapper_->peer_connection_factory()
+             : nullptr;
+}
 
 std::unique_ptr<MessagePipe> WebrtcTransport::CreateOutgoingChannel(
     const std::string& name) {
   webrtc::DataChannelInit config;
   config.reliable = true;
   return base::WrapUnique(new WebrtcDataStreamAdapter(
-      peer_connection_->CreateDataChannel(name, &config)));
+      peer_connection()->CreateDataChannel(name, &config)));
 }
 
 void WebrtcTransport::Start(
     Authenticator* authenticator,
     SendTransportInfoCallback send_transport_info_callback) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(send_transport_info_callback_.is_null());
 
   jingle_glue::JingleThreadWrapper::EnsureForCurrentMessageLoop();
 
   // TODO(sergeyu): Investigate if it's possible to avoid Send().
   jingle_glue::JingleThreadWrapper::current()->set_send_allowed(true);
 
   send_transport_info_callback_ = std::move(send_transport_info_callback);
 
   if (!handshake_hmac_.Init(authenticator->GetAuthKey())) {
     LOG(FATAL) << "HMAC::Init() failed.";
   }
 
-  fake_audio_device_module_.reset(new webrtc::FakeAudioDeviceModule());
   video_encoder_factory_ = new remoting::WebrtcVideoEncoderFactory();
-
-  // Takes ownership of video_encoder_factory_
-  peer_connection_factory_ = webrtc::CreatePeerConnectionFactory(
-      worker_thread_, rtc::Thread::Current(), fake_audio_device_module_.get(),
-      video_encoder_factory_, nullptr);
-
-  webrtc::PeerConnectionInterface::IceServer stun_server;
-  stun_server.urls.push_back("stun:stun.l.google.com:19302");
-  webrtc::PeerConnectionInterface::RTCConfiguration rtc_config;
-  rtc_config.servers.push_back(stun_server);
-
-  webrtc::FakeConstraints constraints;
-  constraints.AddMandatory(webrtc::MediaConstraintsInterface::kEnableDtlsSrtp,
-                           webrtc::MediaConstraintsInterface::kValueTrue);
-
   std::unique_ptr<cricket::PortAllocator> port_allocator =
       transport_context_->port_allocator_factory()->CreatePortAllocator(
           transport_context_);
-  peer_connection_ = peer_connection_factory_->CreatePeerConnection(
-      rtc_config, &constraints, std::move(port_allocator), nullptr, this);
+
+  // Takes ownership of video_encoder_factory_.
+  peer_connection_wrapper_.reset(new PeerConnectionWrapper(
+      worker_thread_, base::WrapUnique(video_encoder_factory_),
+      std::move(port_allocator), weak_factory_.GetWeakPtr()));
 
   event_handler_->OnWebrtcTransportConnecting();
 
   if (transport_context_->role() == TransportRole::SERVER)
     RequestNegotiation();
 }
 
 bool WebrtcTransport::ProcessTransportInfo(XmlElement* transport_info) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   if (transport_info->Name() != QName(kTransportNamespace, "transport"))
     return false;
 
-  if (!peer_connection_)
+  if (!peer_connection())
     return false;
 
   XmlElement* session_description = transport_info->FirstNamed(
       QName(kTransportNamespace, "session-description"));
   if (session_description) {
     webrtc::PeerConnectionInterface::SignalingState expected_state =
         transport_context_->role() == TransportRole::CLIENT
             ? webrtc::PeerConnectionInterface::kStable
             : webrtc::PeerConnectionInterface::kHaveLocalOffer;
-    if (peer_connection_->signaling_state() != expected_state) {
+    if (peer_connection()->signaling_state() != expected_state) {
       LOG(ERROR) << "Received unexpected WebRTC session_description.";
       return false;
     }
 
     std::string type = session_description->Attr(QName(std::string(), "type"));
     std::string sdp =
         NormalizeSessionDescription(session_description->BodyText());
     if (!IsValidSessionDescriptionType(type) || sdp.empty()) {
       LOG(ERROR) << "Incorrect session description format.";
       return false;
@@ skipping 36 matching lines @@
 
     webrtc::SdpParseError error;
     std::unique_ptr<webrtc::SessionDescriptionInterface> session_description(
         webrtc::CreateSessionDescription(type, sdp, &error));
     if (!session_description) {
       LOG(ERROR) << "Failed to parse the session description: "
                  << error.description << " line: " << error.line;
       return false;
     }
 
-    peer_connection_->SetRemoteDescription(
+    peer_connection()->SetRemoteDescription(
         SetSessionDescriptionObserver::Create(
             base::Bind(&WebrtcTransport::OnRemoteDescriptionSet,
                        weak_factory_.GetWeakPtr(),
                        type == webrtc::SessionDescriptionInterface::kOffer)),
         session_description.release());
   }
 
   XmlElement* candidate_element;
   QName candidate_qname(kTransportNamespace, "candidate");
   for (candidate_element = transport_info->FirstNamed(candidate_qname);
@@ skipping 14 matching lines @@
     webrtc::SdpParseError error;
     std::unique_ptr<webrtc::IceCandidateInterface> candidate(
         webrtc::CreateIceCandidate(sdp_mid, sdp_mlineindex, candidate_str,
                                    &error));
     if (!candidate) {
       LOG(ERROR) << "Failed to parse incoming candidate: " << error.description
                  << " line: " << error.line;
       return false;
     }
 
-    if (peer_connection_->signaling_state() ==
+    if (peer_connection()->signaling_state() ==
         webrtc::PeerConnectionInterface::kStable) {
-      if (!peer_connection_->AddIceCandidate(candidate.get())) {
+      if (!peer_connection()->AddIceCandidate(candidate.get())) {
         LOG(ERROR) << "Failed to add incoming ICE candidate.";
         return false;
       }
     } else {
       pending_incoming_candidates_.push_back(std::move(candidate));
     }
   }
 
   return true;
 }
 
 void WebrtcTransport::OnLocalSessionDescriptionCreated(
     std::unique_ptr<webrtc::SessionDescriptionInterface> description,
     const std::string& error) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
-  if (!peer_connection_)
+  if (!peer_connection())
     return;
 
   if (!description) {
     LOG(ERROR) << "PeerConnection offer creation failed: " << error;
     Close(CHANNEL_CONNECTION_ERROR);
     return;
   }
 
   std::string description_sdp;
   if (!description->ToString(&description_sdp)) {
@@ skipping 16 matching lines @@
   digest.resize(handshake_hmac_.DigestLength());
   CHECK(handshake_hmac_.Sign(description->type() + " " + description_sdp,
                              reinterpret_cast<uint8_t*>(&(digest[0])),
                              digest.size()));
   std::string digest_base64;
   base::Base64Encode(digest, &digest_base64);
   offer_tag->SetAttr(QName(std::string(), "signature"), digest_base64);
 
   send_transport_info_callback_.Run(std::move(transport_info));
 
-  peer_connection_->SetLocalDescription(
+  peer_connection()->SetLocalDescription(
       SetSessionDescriptionObserver::Create(base::Bind(
           &WebrtcTransport::OnLocalDescriptionSet, weak_factory_.GetWeakPtr())),
       description.release());
 }
 
 void WebrtcTransport::OnLocalDescriptionSet(bool success,
                                             const std::string& error) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
-  if (!peer_connection_)
+  if (!peer_connection())
     return;
 
   if (!success) {
     LOG(ERROR) << "Failed to set local description: " << error;
     Close(CHANNEL_CONNECTION_ERROR);
     return;
   }
 
   AddPendingCandidatesIfPossible();
 }
 
 void WebrtcTransport::OnRemoteDescriptionSet(bool send_answer,
                                              bool success,
                                              const std::string& error) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
-  if (!peer_connection_)
+  if (!peer_connection())
     return;
 
   if (!success) {
     LOG(ERROR) << "Failed to set local description: " << error;
     Close(CHANNEL_CONNECTION_ERROR);
     return;
   }
 
   // Create and send answer on the server.
   if (send_answer) {
-    peer_connection_->CreateAnswer(
+    peer_connection()->CreateAnswer(
         CreateSessionDescriptionObserver::Create(
             base::Bind(&WebrtcTransport::OnLocalSessionDescriptionCreated,
                        weak_factory_.GetWeakPtr())),
         nullptr);
   }
 
   AddPendingCandidatesIfPossible();
 }
 
 void WebrtcTransport::OnSignalingChange(
@@ skipping 109 matching lines @@
 
   webrtc::FakeConstraints offer_config;
   offer_config.AddMandatory(
       webrtc::MediaConstraintsInterface::kOfferToReceiveVideo,
       webrtc::MediaConstraintsInterface::kValueTrue);
   offer_config.AddMandatory(
       webrtc::MediaConstraintsInterface::kOfferToReceiveAudio,
       webrtc::MediaConstraintsInterface::kValueFalse);
   offer_config.AddMandatory(webrtc::MediaConstraintsInterface::kEnableDtlsSrtp,
                             webrtc::MediaConstraintsInterface::kValueTrue);
-  peer_connection_->CreateOffer(
+  peer_connection()->CreateOffer(
       CreateSessionDescriptionObserver::Create(
           base::Bind(&WebrtcTransport::OnLocalSessionDescriptionCreated,
                      weak_factory_.GetWeakPtr())),
       &offer_config);
 }
 
 void WebrtcTransport::SendTransportInfo() {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(pending_transport_info_message_);
 
   send_transport_info_callback_.Run(std::move(pending_transport_info_message_));
 }
 
 void WebrtcTransport::AddPendingCandidatesIfPossible() {
   DCHECK(thread_checker_.CalledOnValidThread());
 
-  if (peer_connection_->signaling_state() ==
+  if (peer_connection()->signaling_state() ==
       webrtc::PeerConnectionInterface::kStable) {
     for (auto* candidate : pending_incoming_candidates_) {
-      if (!peer_connection_->AddIceCandidate(candidate)) {
+      if (!peer_connection()->AddIceCandidate(candidate)) {
         LOG(ERROR) << "Failed to add incoming candidate";
         Close(INCOMPATIBLE_PROTOCOL);
         return;
       }
     }
     pending_incoming_candidates_.clear();
   }
 }
 
 void WebrtcTransport::Close(ErrorCode error) {
   DCHECK(thread_checker_.CalledOnValidThread());
-  if (!peer_connection_)
+  if (!peer_connection_wrapper_)
     return;
 
   weak_factory_.InvalidateWeakPtrs();
 
-  peer_connection_->Close();
-  peer_connection_ = nullptr;
-  peer_connection_factory_ = nullptr;
+  // Close and delete PeerConnection asynchronously. PeerConnection may be on
+  // the stack and so it must be destroyed later.
+  base::ThreadTaskRunnerHandle::Get()->DeleteSoon(
+      FROM_HERE, peer_connection_wrapper_.release());
 
   if (error != OK)
     event_handler_->OnWebrtcTransportError(error);
 }
 
 }  // namespace protocol
 }  // namespace remoting