Implement WebrtcTransport

remoting/protocol/jingle_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/jingle_session.h"
 
 #include "base/bind.h"
 #include "base/rand_util.h"
 #include "base/single_thread_task_runner.h"
 #include "base/stl_util.h"
@@ skipping 259 matching lines @@
   if (state_ != FAILED && state_ != CLOSED) {
     if (error != OK) {
       SetState(FAILED);
     } else {
       SetState(CLOSED);
     }
   }
 }
 
 void JingleSession::SendMessage(const JingleMessage& message) {
+  DCHECK(CalledOnValidThread());
+
   scoped_ptr<IqRequest> request = session_manager_->iq_sender()->SendIq(
       message.ToXml(),
       base::Bind(&JingleSession::OnMessageResponse,
                  base::Unretained(this),
                  message.action));
 
   int timeout = kDefaultMessageTimeout;
   if (message.action == JingleMessage::SESSION_INITIATE ||
       message.action == JingleMessage::SESSION_ACCEPT) {
     timeout = kSessionInitiateAndAcceptTimeout;
   }
   if (request) {
     request->SetTimeout(base::TimeDelta::FromSeconds(timeout));
     pending_requests_.insert(request.release());
   } else {
     LOG(ERROR) << "Failed to send a "
                << JingleMessage::GetActionName(message.action) << " message";
   }
 }
 
 void JingleSession::OnMessageResponse(
     JingleMessage::ActionType request_type,
     IqRequest* request,
     const buzz::XmlElement* response) {
+  DCHECK(CalledOnValidThread());
+
   // Delete the request from the list of pending requests.
   pending_requests_.erase(request);
   delete request;
 
   // Ignore all responses after session was closed.
   if (state_ == CLOSED || state_ == FAILED)
     return;
 
   std::string type_str = JingleMessage::GetActionName(request_type);
 
@@ skipping 12 matching lines @@
 
       // TODO(sergeyu): There may be different reasons for error
       // here. Parse the response stanza to find failure reason.
       Close(PEER_IS_OFFLINE);
     }
   }
 }
 
 void JingleSession::OnOutgoingTransportInfo(
     scoped_ptr<XmlElement> transport_info) {
+  DCHECK(CalledOnValidThread());
+
   JingleMessage message(peer_jid_, JingleMessage::TRANSPORT_INFO, session_id_);
   message.transport_info = transport_info.Pass();
 
   scoped_ptr<IqRequest> request = session_manager_->iq_sender()->SendIq(
       message.ToXml(), base::Bind(&JingleSession::OnTransportInfoResponse,
                                   base::Unretained(this)));
   if (request) {
     request->SetTimeout(base::TimeDelta::FromSeconds(kTransportInfoTimeout));
     transport_info_requests_.push_back(request.release());
   } else {
     LOG(ERROR) << "Failed to send a transport-info message";
   }
 }
 
 void JingleSession::OnTransportRouteChange(const std::string& channel_name,
                                            const TransportRoute& route) {
+  DCHECK(CalledOnValidThread());
+
   event_handler_->OnSessionRouteChange(channel_name, route);
 }
 
+void JingleSession::OnTransportConnected() {
+  DCHECK(CalledOnValidThread());
+
+  // TODO(sergeyu): Add Session::State value to indicate that the transport has
+  // been connected.
+}
+
 void JingleSession::OnTransportError(ErrorCode error) {
+  DCHECK(CalledOnValidThread());
+
   Close(error);
 }
 
 void JingleSession::OnTransportInfoResponse(IqRequest* request,
                                             const buzz::XmlElement* response) {
+  DCHECK(CalledOnValidThread());
   DCHECK(!transport_info_requests_.empty());
 
   // Consider transport-info requests sent before this one lost and delete
   // corresponding IqRequest objects.
   while (transport_info_requests_.front() != request) {
     delete transport_info_requests_.front();
     transport_info_requests_.pop_front();
   }
 
   // Delete the |request| itself.
@@ skipping 242 matching lines @@
   }
 }
 
 bool JingleSession::is_session_active() {
   return state_ == CONNECTING || state_ == ACCEPTING || state_ == CONNECTED ||
         state_ == AUTHENTICATING || state_ == AUTHENTICATED;
 }
 
 }  // namespace protocol
 }  // namespace remoting