Simplify data channel creation logic in WebRTC-based protocol

remoting/protocol/webrtc_data_stream_adapter.cc

Index: remoting/protocol/webrtc_data_stream_adapter.cc
diff --git a/remoting/protocol/webrtc_data_stream_adapter.cc b/remoting/protocol/webrtc_data_stream_adapter.cc
index 15c97aef14db23ce02bd26d497fa619fb2f3b0a9..85009b6516d0f7156b6e272a4253845abf2beb50 100644
--- a/remoting/protocol/webrtc_data_stream_adapter.cc
+++ b/remoting/protocol/webrtc_data_stream_adapter.cc
@@ -21,13 +21,14 @@
 namespace remoting {
 namespace protocol {
 
-class WebrtcDataStreamAdapter::Channel : public MessagePipe,
-                                         public webrtc::DataChannelObserver {
- public:
-  explicit Channel(WebrtcDataStreamAdapter* adapter);
-  ~Channel() override;
+namespace {
 
-  void Start(rtc::scoped_refptr<webrtc::DataChannelInterface> channel);
+class WebrtcDataChannel : public MessagePipe,
+                          public webrtc::DataChannelObserver {
+ public:
+  explicit WebrtcDataChannel(
+      rtc::scoped_refptr<webrtc::DataChannelInterface> channel);
+  ~WebrtcDataChannel() override;
 
   std::string name() { return channel_->label(); }
 
@@ -47,52 +48,38 @@ class WebrtcDataStreamAdapter::Channel : public MessagePipe,
 
   void OnClosed();
 
-  // |adapter_| owns channels while they are being connected.
-  WebrtcDataStreamAdapter* adapter_;
-
   rtc::scoped_refptr<webrtc::DataChannelInterface> channel_;
 
   EventHandler* event_handler_ = nullptr;
 
   State state_ = State::CONNECTING;
 
-  DISALLOW_COPY_AND_ASSIGN(Channel);
+  DISALLOW_COPY_AND_ASSIGN(WebrtcDataChannel);
 };
 
-WebrtcDataStreamAdapter::Channel::Channel(WebrtcDataStreamAdapter* adapter)
-    : adapter_(adapter) {}
+WebrtcDataChannel::WebrtcDataChannel(
+    rtc::scoped_refptr<webrtc::DataChannelInterface> channel)
+    : channel_(channel) {
+  channel_->RegisterObserver(this);
+  DCHECK_EQ(channel_->state(), webrtc::DataChannelInterface::kConnecting);
+}
 
-WebrtcDataStreamAdapter::Channel::~Channel() {
+WebrtcDataChannel::~WebrtcDataChannel() {
   if (channel_) {
     channel_->UnregisterObserver();
     channel_->Close();
   }
 }
 
-void WebrtcDataStreamAdapter::Channel::Start(
-    rtc::scoped_refptr<webrtc::DataChannelInterface> channel) {
-  DCHECK(!channel_);
-
-  channel_ = channel;
-  channel_->RegisterObserver(this);
-
-   if (channel_->state() == webrtc::DataChannelInterface::kOpen) {
-    OnConnected();
-  } else {
-    DCHECK_EQ(channel_->state(), webrtc::DataChannelInterface::kConnecting);
-  }
-}
-
-void WebrtcDataStreamAdapter::Channel::Start(EventHandler* event_handler) {
+void WebrtcDataChannel::Start(EventHandler* event_handler) {
   DCHECK(!event_handler_);
   DCHECK(event_handler);
 
   event_handler_ = event_handler;
 }
 
-void WebrtcDataStreamAdapter::Channel::Send(
-    google::protobuf::MessageLite* message,
-    const base::Closure& done) {
+void WebrtcDataChannel::Send(google::protobuf::MessageLite* message,
+                             const base::Closure& done) {
   DCHECK(state_ == State::OPEN);
 
   rtc::CopyOnWriteBuffer buffer;
@@ -110,14 +97,19 @@ void WebrtcDataStreamAdapter::Channel::Send(
     done.Run();
 }
 
-void WebrtcDataStreamAdapter::Channel::OnStateChange() {
+void WebrtcDataChannel::OnStateChange() {
   switch (channel_->state()) {
     case webrtc::DataChannelInterface::kOpen:
-      OnConnected();
+      DCHECK(state_ == State::CONNECTING);
+      state_ = State::OPEN;
+      event_handler_->OnMessagePipeOpen();
       break;
 
     case webrtc::DataChannelInterface::kClosing:
-      OnClosed();
+      if (state_ != State::CLOSED) {
+        state_ = State::CLOSED;
+        event_handler_->OnMessagePipeClosed();
+      }
       break;
 
     case webrtc::DataChannelInterface::kConnecting:
@@ -126,8 +118,7 @@ void WebrtcDataStreamAdapter::Channel::OnStateChange() {
   }
 }
 
-void WebrtcDataStreamAdapter::Channel::OnMessage(
-    const webrtc::DataBuffer& rtc_buffer) {
+void WebrtcDataChannel::OnMessage(const webrtc::DataBuffer& rtc_buffer) {
   if (state_ != State::OPEN) {
     LOG(ERROR) << "Dropping a message received when the channel is not open.";
     return;
@@ -140,114 +131,24 @@ void WebrtcDataStreamAdapter::Channel::OnMessage(
   event_handler_->OnMessageReceived(std::move(buffer));
 }
 
-void WebrtcDataStreamAdapter::Channel::OnConnected() {
-  DCHECK(state_ == State::CONNECTING);
-  state_ = State::OPEN;
-  WebrtcDataStreamAdapter* adapter = adapter_;
-  adapter_ = nullptr;
-  adapter->OnChannelConnected(this);
-}
-
-void WebrtcDataStreamAdapter::Channel::OnClosed() {
-  switch (state_) {
-    case State::CONNECTING:
-      state_ = State::CLOSED;
-      LOG(WARNING) << "Channel " << channel_->label()
-                   << " was closed before it's connected.";
-      adapter_->OnChannelError();
-      return;
-
-    case State::OPEN:
-      state_ = State::CLOSED;
-      event_handler_->OnMessagePipeClosed();
-      return;
-
-    case State::CLOSED:
-      break;
-  }
-}
-
-struct WebrtcDataStreamAdapter::PendingChannel {
-  PendingChannel(std::unique_ptr<Channel> channel,
-                 const ChannelCreatedCallback& connected_callback)
-      : channel(std::move(channel)), connected_callback(connected_callback) {}
-  PendingChannel(PendingChannel&& other)
-      : channel(std::move(other.channel)),
-        connected_callback(std::move(other.connected_callback)) {}
-  PendingChannel& operator=(PendingChannel&& other) {
-    channel = std::move(other.channel);
-    connected_callback = std::move(other.connected_callback);
-    return *this;
-  }
-
-  std::unique_ptr<Channel> channel;
-  ChannelCreatedCallback connected_callback;
-};
+}  // namespace
 
 WebrtcDataStreamAdapter::WebrtcDataStreamAdapter(
-    const ErrorCallback& error_callback)
-    : error_callback_(error_callback) {}
+    rtc::scoped_refptr<webrtc::PeerConnectionInterface> peer_connection)
+    : peer_connection_(peer_connection) {}
+WebrtcDataStreamAdapter::~WebrtcDataStreamAdapter() {}
 
-WebrtcDataStreamAdapter::~WebrtcDataStreamAdapter() {
-  DCHECK(pending_channels_.empty());
-}
-
-void WebrtcDataStreamAdapter::Initialize(
-    rtc::scoped_refptr<webrtc::PeerConnectionInterface> peer_connection) {
-  peer_connection_ = peer_connection;
-}
-
-void WebrtcDataStreamAdapter::WrapIncomingDataChannel(
-    rtc::scoped_refptr<webrtc::DataChannelInterface> data_channel,
-    const ChannelCreatedCallback& callback) {
-  AddPendingChannel(data_channel, callback);
-}
-
-void WebrtcDataStreamAdapter::CreateChannel(
-    const std::string& name,
-    const ChannelCreatedCallback& callback) {
+std::unique_ptr<MessagePipe> WebrtcDataStreamAdapter::CreateOutgoingChannel(
+    const std::string& name) {
   webrtc::DataChannelInit config;
   config.reliable = true;
-  AddPendingChannel(peer_connection_->CreateDataChannel(name, &config),
-                    callback);
-}
-
-void WebrtcDataStreamAdapter::CancelChannelCreation(const std::string& name) {
-  auto it = pending_channels_.find(name);
-  DCHECK(it != pending_channels_.end());
-  pending_channels_.erase(it);
-}
-
-void WebrtcDataStreamAdapter::AddPendingChannel(
-    rtc::scoped_refptr<webrtc::DataChannelInterface> data_channel,
-    const ChannelCreatedCallback& callback) {
-  DCHECK(peer_connection_);
-  DCHECK(pending_channels_.find(data_channel->label()) ==
-         pending_channels_.end());
-
-  Channel* channel = new Channel(this);
-  pending_channels_.insert(
-      std::make_pair(data_channel->label(),
-                     PendingChannel(base::WrapUnique(channel), callback)));
-
-  channel->Start(data_channel);
-}
-
-void WebrtcDataStreamAdapter::OnChannelConnected(Channel* channel) {
-  auto it = pending_channels_.find(channel->name());
-  DCHECK(it != pending_channels_.end());
-
-  PendingChannel pending_channel = std::move(it->second);
-  pending_channels_.erase(it);
-
-  // Once the channel is connected its ownership  is passed to the
-  // |connected_callback|.
-  pending_channel.connected_callback.Run(std::move(pending_channel.channel));
+  return base::WrapUnique(new WebrtcDataChannel(
+      peer_connection_->CreateDataChannel(name, &config)));
 }
 
-void WebrtcDataStreamAdapter::OnChannelError() {
-  pending_channels_.clear();
-  error_callback_.Run(CHANNEL_CONNECTION_ERROR);
+std::unique_ptr<MessagePipe> WebrtcDataStreamAdapter::WrapIncomingDataChannel(
+    rtc::scoped_refptr<webrtc::DataChannelInterface> data_channel) {
+  return base::WrapUnique(new WebrtcDataChannel(data_channel));
 }
 
 }  // namespace protocol