Add TransportContext class.

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 "base/callback_helpers.h"
 #include "base/single_thread_task_runner.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/task_runner_util.h"
 #include "base/thread_task_runner_handle.h"
 #include "jingle/glue/thread_wrapper.h"
+#include "remoting/protocol/transport_context.h"
 #include "third_party/libjingle/source/talk/app/webrtc/test/fakeconstraints.h"
 #include "third_party/webrtc/libjingle/xmllite/xmlelement.h"
 #include "third_party/webrtc/modules/audio_device/include/fake_audio_device.h"
 
 using buzz::QName;
 using buzz::XmlElement;
 
 namespace remoting {
 namespace protocol {
 
@@ skipping 71 matching lines @@
  private:
   ResultCallback result_callback_;
 
   DISALLOW_COPY_AND_ASSIGN(SetSessionDescriptionObserver);
 };
 
 }  // namespace
 
 WebrtcTransport::WebrtcTransport(
     rtc::Thread* worker_thread,
-    rtc::scoped_refptr<webrtc::PortAllocatorFactoryInterface>
-        port_allocator_factory,
-    TransportRole role)
-    : port_allocator_factory_(port_allocator_factory),
-      role_(role),
+    scoped_refptr<TransportContext> transport_context)
+    : transport_context_(transport_context),
       worker_thread_(worker_thread),
       weak_factory_(this) {}
 
 WebrtcTransport::~WebrtcTransport() {}
 
 void WebrtcTransport::Start(EventHandler* event_handler,
                             Authenticator* authenticator) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   event_handler_ = event_handler;
+  // TODO(sergeyu): Use the |authenticator| to authenticate PeerConnection.
 
-  // TODO(sergeyu): Use the |authenticator| to authenticate PeerConnection.
+  transport_context_->CreatePortAllocator(base::Bind(
+      &WebrtcTransport::OnPortAllocatorCreated, weak_factory_.GetWeakPtr()));
+}
+
+void WebrtcTransport::OnPortAllocatorCreated(
+    scoped_ptr<cricket::PortAllocator> port_allocator) {
   jingle_glue::JingleThreadWrapper::EnsureForCurrentMessageLoop();
 
   // TODO(sergeyu): Investigate if it's possible to avoid Send().
   jingle_glue::JingleThreadWrapper::current()->set_send_allowed(true);
 
   fake_audio_device_module_.reset(new webrtc::FakeAudioDeviceModule());
 
   peer_connection_factory_ = webrtc::CreatePeerConnectionFactory(
       worker_thread_, rtc::Thread::Current(),
       fake_audio_device_module_.get(), nullptr, 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);
 
   peer_connection_ = peer_connection_factory_->CreatePeerConnection(
-      rtc_config, &constraints, port_allocator_factory_, nullptr, this);
+      rtc_config, &constraints,
+      rtc::scoped_ptr<cricket::PortAllocator>(port_allocator.release()),
+      nullptr, this);
 
-  data_stream_adapter_.Initialize(peer_connection_,
-                                  role_ == TransportRole::SERVER);
+  data_stream_adapter_.Initialize(
+      peer_connection_, transport_context_->role() == TransportRole::SERVER);
 
-  if (role_ == TransportRole::SERVER)
+  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_)
     return false;
 
   XmlElement* session_description = transport_info->FirstNamed(
       QName(kTransportNamespace, "session-description"));
   if (session_description) {
     webrtc::PeerConnectionInterface::SignalingState expected_state =
-        role_ == TransportRole::CLIENT
+        transport_context_->role() == TransportRole::CLIENT
             ? webrtc::PeerConnectionInterface::kStable
             : webrtc::PeerConnectionInterface::kHaveLocalOffer;
     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 = session_description->BodyText();
     if (type.empty() || sdp.empty()) {
@@ skipping 182 matching lines @@
 
 void WebrtcTransport::OnDataChannel(
     webrtc::DataChannelInterface* data_channel) {
   DCHECK(thread_checker_.CalledOnValidThread());
   data_stream_adapter_.OnIncomingDataChannel(data_channel);
 }
 
 void WebrtcTransport::OnRenegotiationNeeded() {
   DCHECK(thread_checker_.CalledOnValidThread());
 
-  if (role_ == TransportRole::SERVER) {
+  if (transport_context_->role() == TransportRole::SERVER) {
     RequestNegotiation();
   } else {
     // TODO(sergeyu): Is it necessary to support renegotiation initiated by the
     // client?
     NOTIMPLEMENTED();
   }
 }
 
 void WebrtcTransport::RequestNegotiation() {
-  DCHECK(role_ == TransportRole::SERVER);
+  DCHECK(transport_context_->role() == TransportRole::SERVER);
 
   if (!negotiation_pending_) {
     negotiation_pending_ = true;
     base::ThreadTaskRunnerHandle::Get()->PostTask(
         FROM_HERE,
         base::Bind(&WebrtcTransport::SendOffer, weak_factory_.GetWeakPtr()));
   }
 }
 
 void WebrtcTransport::OnIceConnectionChange(
@@ skipping 44 matching lines @@
 
     // Delay sending the new candidates in case we get more candidates
     // that we can send in one message.
     transport_info_timer_.Start(
         FROM_HERE, base::TimeDelta::FromMilliseconds(kTransportInfoSendDelayMs),
         this, &WebrtcTransport::SendTransportInfo);
   }
 }
 
 void WebrtcTransport::SendOffer() {
-  DCHECK(role_ == TransportRole::SERVER);
+  DCHECK(transport_context_->role() == TransportRole::SERVER);
 
   DCHECK(negotiation_pending_);
   negotiation_pending_ = false;
 
   webrtc::FakeConstraints offer_config;
   offer_config.AddMandatory(
       webrtc::MediaConstraintsInterface::kOfferToReceiveVideo,
       webrtc::MediaConstraintsInterface::kValueTrue);
   offer_config.AddMandatory(
       webrtc::MediaConstraintsInterface::kOfferToReceiveAudio,
@@ skipping 27 matching lines @@
         Close(INCOMPATIBLE_PROTOCOL);
         return;
       }
     }
     pending_incoming_candidates_.clear();
   }
 }
 
 WebrtcTransportFactory::WebrtcTransportFactory(
     rtc::Thread* worker_thread,
-    SignalStrategy* signal_strategy,
-    rtc::scoped_refptr<webrtc::PortAllocatorFactoryInterface>
-        port_allocator_factory,
-    TransportRole role)
+    scoped_refptr<TransportContext> transport_context)
     : worker_thread_(worker_thread),
-      signal_strategy_(signal_strategy),
-      port_allocator_factory_(port_allocator_factory),
-      role_(role) {}
+      transport_context_(transport_context) {}
 
 WebrtcTransportFactory::~WebrtcTransportFactory() {}
 
 scoped_ptr<Transport> WebrtcTransportFactory::CreateTransport() {
   return make_scoped_ptr(
-      new WebrtcTransport(worker_thread_, port_allocator_factory_, role_));
+      new WebrtcTransport(worker_thread_, transport_context_.get()));
 }
 
 }  // namespace protocol
 }  // namespace remoting