Add abstract interfaces for the transport layer.

remoting/protocol/pepper_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/protocol/pepper_session.h"
 
 #include "base/bind.h"
 #include "base/rand_util.h"
 #include "base/stl_util.h"
 #include "base/string_number_conversions.h"
 #include "remoting/base/constants.h"
 #include "remoting/jingle_glue/iq_sender.h"
 #include "remoting/protocol/authenticator.h"
+#include "remoting/protocol/channel_authenticator.h"
 #include "remoting/protocol/content_description.h"
 #include "remoting/protocol/jingle_messages.h"
 #include "remoting/protocol/pepper_session_manager.h"
-#include "remoting/protocol/pepper_stream_channel.h"
 #include "third_party/libjingle/source/talk/p2p/base/candidate.h"
 #include "third_party/libjingle/source/talk/xmllite/xmlelement.h"
 
 using buzz::XmlElement;
 
 namespace remoting {
 namespace protocol {
 
 namespace {
 // Delay after candidate creation before sending transport-info
@@ skipping 86 matching lines @@
   CloseInternal(true);
 }
 
 void PepperSession::CreateStreamChannel(
       const std::string& name,
       const StreamChannelCallback& callback) {
   DCHECK(!channels_[name]);
 
   scoped_ptr<ChannelAuthenticator> channel_authenticator =
       authenticator_->CreateChannelAuthenticator();
-  PepperStreamChannel* channel = new PepperStreamChannel(
-      this, name, callback);
-  channels_[name] = channel;
-  channel->Connect(session_manager_->pp_instance_,
-                   session_manager_->transport_config_,
-                   channel_authenticator.Pass());
+  scoped_ptr<StreamTransport> channel =
+      session_manager_->transport_factory_->CreateStreamTransport();
+  channel->Initialize(name, session_manager_->transport_config_,
+                      this, channel_authenticator.Pass());
+  channel->Connect(callback);
+  channels_[name] = channel.release();
 }
 
 void PepperSession::CreateDatagramChannel(
     const std::string& name,
     const DatagramChannelCallback& callback) {
-  // TODO(sergeyu): Implement datagram channel support.
-  NOTREACHED();
+  DCHECK(!channels_[name]);
+
+  scoped_ptr<ChannelAuthenticator> channel_authenticator =
+      authenticator_->CreateChannelAuthenticator();
+  scoped_ptr<DatagramTransport> channel =
+      session_manager_->transport_factory_->CreateDatagramTransport();
+  channel->Initialize(name, session_manager_->transport_config_,
+                      this, channel_authenticator.Pass());
+  channel->Connect(callback);
+  channels_[name] = channel.release();
 }
 
 void PepperSession::CancelChannelCreation(const std::string& name) {
   ChannelsMap::iterator it = channels_.find(name);
   if (it != channels_.end() && !it->second->is_connected()) {
     delete it->second;
     DCHECK(!channels_[name]);
   }
 }
 
@@ skipping 26 matching lines @@
     JingleMessage message(peer_jid_, JingleMessage::SESSION_TERMINATE,
                           session_id_);
     scoped_ptr<IqRequest> terminate_request(
         session_manager_->iq_sender()->SendIq(
             message.ToXml(), IqSender::ReplyCallback()));
   }
 
   CloseInternal(false);
 }
 
+void PepperSession::OnTransportCandidate(Transport* transport,
+                                         const cricket::Candidate& candidate) {
+  pending_candidates_.push_back(candidate);
+
+  if (!transport_infos_timer_.IsRunning()) {
+    // Delay sending the new candidates in case we get more candidates
+    // that we can send in one message.
+    transport_infos_timer_.Start(
+        FROM_HERE, base::TimeDelta::FromMilliseconds(kTransportInfoSendDelayMs),
+        this, &PepperSession::SendTransportInfo);
+  }
+}
+
+void PepperSession::OnTransportDeleted(Transport* transport) {
+  ChannelsMap::iterator it = channels_.find(transport->name());
+  DCHECK_EQ(it->second, transport);
+  channels_.erase(it);
+}
+
 void PepperSession::OnIncomingMessage(const JingleMessage& message,
                                       JingleMessageReply* reply) {
   DCHECK(CalledOnValidThread());
 
   if (message.from != peer_jid_) {
     // Ignore messages received from a different Jid.
     *reply = JingleMessageReply(JingleMessageReply::INVALID_SID);
     return;
   }
 
@@ skipping 174 matching lines @@
 void PepperSession::OnSessionInfoResponse(const buzz::XmlElement* response) {
   const std::string& type = response->Attr(buzz::QName("", "type"));
   if (type != "result") {
     LOG(ERROR) << "Received error in response to session-info message: \""
                << response->Str()
                << "\". Terminating the session.";
     OnError(INCOMPATIBLE_PROTOCOL);
   }
 }
 
-void PepperSession::AddLocalCandidate(const cricket::Candidate& candidate) {
-  pending_candidates_.push_back(candidate);
-
-  if (!transport_infos_timer_.IsRunning()) {
-    // Delay sending the new candidates in case we get more candidates
-    // that we can send in one message.
-    transport_infos_timer_.Start(
-        FROM_HERE, base::TimeDelta::FromMilliseconds(kTransportInfoSendDelayMs),
-        this, &PepperSession::SendTransportInfo);
-  }
-}
-
 void PepperSession::OnTransportInfoResponse(const buzz::XmlElement* response) {
   const std::string& type = response->Attr(buzz::QName("", "type"));
   if (type != "result") {
     LOG(ERROR) << "Received error in response to session-initiate message: \""
                << response->Str()
                << "\". Terminating the session.";
 
     if (state_ == CONNECTING) {
       OnError(PEER_IS_OFFLINE);
     } else {
       // Host has disconnected without sending session-terminate message.
       CloseInternal(false);
     }
   }
 }
 
-void PepperSession::OnDeleteChannel(PepperChannel* channel) {
-  ChannelsMap::iterator it = channels_.find(channel->name());
-  DCHECK_EQ(it->second, channel);
-  channels_.erase(it);
-}
-
 void PepperSession::SendTransportInfo() {
   JingleMessage message(peer_jid_, JingleMessage::TRANSPORT_INFO, session_id_);
   message.candidates.swap(pending_candidates_);
   transport_info_request_.reset(session_manager_->iq_sender()->SendIq(
       message.ToXml(), base::Bind(
           &PepperSession::OnTransportInfoResponse,
           base::Unretained(this))));
 }
 
 
@@ skipping 16 matching lines @@
     DCHECK_NE(state_, FAILED);
 
     state_ = new_state;
     if (!state_change_callback_.is_null())
       state_change_callback_.Run(new_state);
   }
 }
 
 }  // namespace protocol
 }  // namespace remoting