TransportController refactoring

webrtc/p2p/base/rawtransportchannel.cc

 /*
  *  Copyright 2004 The WebRTC Project Authors. All rights reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
 #include "webrtc/p2p/base/rawtransportchannel.h"
 
 #include <string>
 #include <vector>
 #include "webrtc/p2p/base/constants.h"
 #include "webrtc/p2p/base/portallocator.h"
 #include "webrtc/p2p/base/portinterface.h"
 #include "webrtc/p2p/base/rawtransport.h"
 #include "webrtc/p2p/base/relayport.h"
 #include "webrtc/p2p/base/stunport.h"
 #include "webrtc/base/common.h"
 
 #if defined(FEATURE_ENABLE_PSTN)
 
-namespace {
-
-const uint32 MSG_DESTROY_RTC_UNUSED_PORTS = 1;
-
-}  // namespace
-
 namespace cricket {
 
 RawTransportChannel::RawTransportChannel(const std::string& content_name,
                                          int component,
                                          RawTransport* transport,
-                                         rtc::Thread *worker_thread,
-                                         PortAllocator *allocator)
-  : TransportChannelImpl(content_name, component),
-    raw_transport_(transport),
-    allocator_(allocator),
-    allocator_session_(NULL),
-    stun_port_(NULL),
-    relay_port_(NULL),
-    port_(NULL),
-    use_relay_(false) {
-  if (worker_thread == NULL)
-    worker_thread_ = raw_transport_->worker_thread();
-  else
-    worker_thread_ = worker_thread;
+                                         PortAllocator* allocator)
+    : TransportChannelImpl(content_name, component),
+      raw_transport_(transport),
+      allocator_(allocator),
+      allocator_session_(NULL),
+      stun_port_(NULL),
+      relay_port_(NULL),
+      port_(NULL),
+      use_relay_(false) {
 }
 
 RawTransportChannel::~RawTransportChannel() {
   delete allocator_session_;
 }
 
 int RawTransportChannel::SendPacket(const char *data, size_t size,
                                     const rtc::PacketOptions& options,
                                     int flags) {
   if (port_ == NULL)
@@ skipping 91 matching lines @@
   if (port->Type() == STUN_PORT_TYPE) {
     stun_port_ = static_cast<StunPort*>(port);
   } else if (port->Type() == RELAY_PORT_TYPE) {
     relay_port_ = static_cast<RelayPort*>(port);
   } else {
     ASSERT(false);
   }
 }
 
 void RawTransportChannel::OnCandidatesReady(
-    PortAllocatorSession *session, const std::vector<Candidate>& candidates) {
+    PortAllocatorSession* session,
+    const std::vector<Candidate>& candidates) {
   ASSERT(session == allocator_session_);
   ASSERT(candidates.size() >= 1);
 
   // The most recent candidate is the one we haven't seen yet.
   Candidate c = candidates[candidates.size() - 1];
 
   if (c.type() == STUN_PORT_TYPE) {
     ASSERT(stun_port_ != NULL);
 
 #if defined(FEATURE_ENABLE_STUN_CLASSIFICATION)
@@ skipping 28 matching lines @@
     ASSERT(false);
   }
 }
 
 void RawTransportChannel::SetPort(PortInterface* port) {
   ASSERT(port_ == NULL);
   port_ = port;
 
   // We don't need any ports other than the one we picked.
   allocator_session_->StopGettingPorts();
-  worker_thread_->Post(
-      this, MSG_DESTROY_RTC_UNUSED_PORTS, NULL);
+  DestroyUnusedPorts();
 
   // Send a message to the other client containing our address.
 
   ASSERT(port_->Candidates().size() >= 1);
   ASSERT(port_->Candidates()[0].protocol() == "udp");
-  SignalCandidateReady(this, port_->Candidates()[0]);
+  SignalCandidateGathered(this, port_->Candidates()[0]);
 
   // Read all packets from this port.
   port_->EnablePortPackets();
   port_->SignalReadPacket.connect(this, &RawTransportChannel::OnReadPacket);
 
   // We can write once we have a port and a remote address.
   if (!remote_address_.IsAny())
     SetWritable();
 }
 
 void RawTransportChannel::SetWritable() {
   ASSERT(port_ != NULL);
   ASSERT(!remote_address_.IsAny());
 
   set_writable(true);
 
   Candidate remote_candidate;
   remote_candidate.set_address(remote_address_);
   SignalRouteChange(this, remote_candidate);
 }
 
 void RawTransportChannel::OnReadPacket(
     PortInterface* port, const char* data, size_t size,
     const rtc::SocketAddress& addr) {
   ASSERT(port_ == port);
   SignalReadPacket(this, data, size, rtc::CreatePacketTime(0), 0);
 }
 
-void RawTransportChannel::OnMessage(rtc::Message* msg) {
-  ASSERT(msg->message_id == MSG_DESTROY_RTC_UNUSED_PORTS);
+void RawTransportChannel::DestroyUnusedPorts() {
   ASSERT(port_ != NULL);
   if (port_ != stun_port_) {
     stun_port_->Destroy();
     stun_port_ = NULL;
   }
   if (port_ != relay_port_ && relay_port_ != NULL) {
     relay_port_->Destroy();
     relay_port_ = NULL;
   }
 }
 
 }  // namespace cricket
 #endif  // defined(FEATURE_ENABLE_PSTN)