Reland of Moving MediaStreamSignaling logic into PeerConnection.

talk/app/webrtc/datachannel.cc

 /*
  * libjingle
  * Copyright 2012 Google Inc.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:
  *
  *  1. Redistributions of source code must retain the above copyright notice,
  *     this list of conditions and the following disclaimer.
  *  2. Redistributions in binary form must reproduce the above copyright notice,
@@ skipping 13 matching lines @@
  * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
  * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #include "talk/app/webrtc/datachannel.h"
 
 #include <string>
 
 #include "talk/app/webrtc/mediastreamprovider.h"
 #include "talk/app/webrtc/sctputils.h"
+#include "talk/media/sctp/sctpdataengine.h"
 #include "webrtc/base/logging.h"
 #include "webrtc/base/refcount.h"
 
 namespace webrtc {
 
 static size_t kMaxQueuedReceivedDataBytes = 16 * 1024 * 1024;
 static size_t kMaxQueuedSendDataBytes = 16 * 1024 * 1024;
 
 enum {
   MSG_CHANNELREADY,
 };
 
+bool SctpSidAllocator::AllocateSid(rtc::SSLRole role, int* sid) {
+  int potential_sid = (role == rtc::SSL_CLIENT) ? 0 : 1;
+  while (!IsSidAvailable(potential_sid)) {
+    potential_sid += 2;
+    if (potential_sid > static_cast<int>(cricket::kMaxSctpSid)) {
+      return false;
+    }
+  }
+
+  *sid = potential_sid;
+  used_sids_.insert(potential_sid);
+  return true;
+}
+
+bool SctpSidAllocator::ReserveSid(int sid) {
+  if (!IsSidAvailable(sid)) {
+    return false;
+  }
+  used_sids_.insert(sid);
+  return true;
+}
+
+void SctpSidAllocator::ReleaseSid(int sid) {
+  auto it = used_sids_.find(sid);
+  if (it != used_sids_.end()) {
+    used_sids_.erase(it);
+  }
+}
+
+bool SctpSidAllocator::IsSidAvailable(int sid) const {
+  if (sid < 0 || sid > static_cast<int>(cricket::kMaxSctpSid)) {
+    return false;
+  }
+  return used_sids_.find(sid) == used_sids_.end();
+}
+
 DataChannel::PacketQueue::PacketQueue() : byte_count_(0) {}
 
 DataChannel::PacketQueue::~PacketQueue() {
   Clear();
 }
 
 bool DataChannel::PacketQueue::Empty() const {
   return packets_.empty();
 }
 
@@ skipping 194 matching lines @@
   UpdateState();
 }
 
 // The remote peer request that this channel shall be closed.
 void DataChannel::RemotePeerRequestClose() {
   DoClose();
 }
 
 void DataChannel::SetSctpSid(int sid) {
   ASSERT(config_.id < 0 && sid >= 0 && data_channel_type_ == cricket::DCT_SCTP);
-  if (config_.id == sid)
+  if (config_.id == sid) {
     return;
+  }
 
   config_.id = sid;
   provider_->AddSctpDataStream(sid);
 }
 
 void DataChannel::OnTransportChannelCreated() {
   ASSERT(data_channel_type_ == cricket::DCT_SCTP);
   if (!connected_to_provider_) {
     connected_to_provider_ = provider_->ConnectDataChannel(this);
   }
   // The sid may have been unassigned when provider_->ConnectDataChannel was
   // done. So always add the streams even if connected_to_provider_ is true.
   if (config_.id >= 0) {
     provider_->AddSctpDataStream(config_.id);
   }
 }
 
+// The underlying transport channel was destroyed.
+// This function makes sure the DataChannel is disconnected and changes state to
+// kClosed.
+void DataChannel::OnTransportChannelDestroyed() {
+  DoClose();
+}
+
 void DataChannel::SetSendSsrc(uint32_t send_ssrc) {
   ASSERT(data_channel_type_ == cricket::DCT_RTP);
   if (send_ssrc_set_) {
     return;
   }
   send_ssrc_ = send_ssrc;
   send_ssrc_set_ = true;
   UpdateState();
 }
 
 void DataChannel::OnMessage(rtc::Message* msg) {
   switch (msg->message_id) {
     case MSG_CHANNELREADY:
       OnChannelReady(true);
       break;
   }
 }
 
-// The underlaying data engine is closing.
-// This function makes sure the DataChannel is disconnected and changes state to
-// kClosed.
-void DataChannel::OnDataEngineClose() {
-  DoClose();
-}
-
 void DataChannel::OnDataReceived(cricket::DataChannel* channel,
                                  const cricket::ReceiveDataParams& params,
                                  const rtc::Buffer& payload) {
   uint32_t expected_ssrc =
       (data_channel_type_ == cricket::DCT_RTP) ? receive_ssrc_ : config_.id;
   if (params.ssrc != expected_ssrc) {
     return;
   }
 
   if (params.type == cricket::DMT_CONTROL) {
@@ skipping 40 matching lines @@
       if (data_channel_type_ != cricket::DCT_RTP) {
         Close();
       }
 
       return;
     }
     queued_received_data_.Push(buffer.release());
   }
 }
 
+void DataChannel::OnStreamClosedRemotely(uint32_t sid) {
+  if (data_channel_type_ == cricket::DCT_SCTP && sid == config_.id) {
+    Close();
+  }
+}
+
 void DataChannel::OnChannelReady(bool writable) {
   writable_ = writable;
   if (!writable) {
     return;
   }
 
   SendQueuedControlMessages();
   SendQueuedDataMessages();
   UpdateState();
 }
@@ skipping 55 matching lines @@
         }
       }
       break;
     }
     case kClosed:
       break;
   }
 }
 
 void DataChannel::SetState(DataState state) {
-  if (state_ == state)
+  if (state_ == state) {
     return;
+  }
 
   state_ = state;
   if (observer_) {
     observer_->OnStateChange();
   }
+  if (state_ == kClosed) {
+    SignalClosed(this);
+  }
 }
 
 void DataChannel::DisconnectFromProvider() {
   if (!connected_to_provider_)
     return;
 
   provider_->DisconnectDataChannel(this);
   connected_to_provider_ = false;
 
   if (data_channel_type_ == cricket::DCT_SCTP && config_.id >= 0) {
@@ skipping 142 matching lines @@
     QueueControlMessage(buffer);
   } else {
     LOG(LS_ERROR) << "Closing the DataChannel due to a failure to send"
                   << " the CONTROL message, send_result = " << send_result;
     Close();
   }
   return retval;
 }
 
 }  // namespace webrtc