Don't start PseudoTCP until underlying transport is connect.

remoting/protocol/libjingle_transport_factory.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/libjingle_transport_factory.h"
 
 #include "base/callback.h"
 #include "base/single_thread_task_runner.h"
 #include "base/thread_task_runner_handle.h"
 #include "base/timer/timer.h"
@@ skipping 37 matching lines @@
   virtual void Connect(
       const std::string& name,
       Transport::EventHandler* event_handler,
       const Transport::ConnectedCallback& callback) OVERRIDE;
   virtual void AddRemoteCandidate(const cricket::Candidate& candidate) OVERRIDE;
   virtual const std::string& name() const OVERRIDE;
   virtual bool is_connected() const OVERRIDE;
 
  private:
   void DoStart();
+  void NotifyConnected();
 
   // Signal handlers for cricket::TransportChannel.
   void OnRequestSignaling(cricket::TransportChannelImpl* channel);
   void OnCandidateReady(cricket::TransportChannelImpl* channel,
                         const cricket::Candidate& candidate);
   void OnRouteChange(cricket::TransportChannel* channel,
                      const cricket::Candidate& candidate);
   void OnWritableState(cricket::TransportChannel* channel);
 
   // Callback for jingle_glue::TransportChannelSocketAdapter to notify when the
@@ skipping 13 matching lines @@
   std::string ice_password_;
 
   bool can_start_;
 
   std::list<cricket::Candidate> pending_candidates_;
   scoped_ptr<cricket::P2PTransportChannel> channel_;
   bool channel_was_writable_;
   int connect_attempts_left_;
   base::RepeatingTimer<LibjingleTransport> reconnect_timer_;
 
+  base::WeakPtrFactory<LibjingleTransport> weak_factory_;
+
   DISALLOW_COPY_AND_ASSIGN(LibjingleTransport);
 };
 
-LibjingleTransport::LibjingleTransport(
-    cricket::PortAllocator* port_allocator,
-    const NetworkSettings& network_settings)
+LibjingleTransport::LibjingleTransport(cricket::PortAllocator* port_allocator,
+                                       const NetworkSettings& network_settings)
     : port_allocator_(port_allocator),
       network_settings_(network_settings),
       event_handler_(NULL),
       ice_username_fragment_(
           rtc::CreateRandomString(cricket::ICE_UFRAG_LENGTH)),
       ice_password_(rtc::CreateRandomString(cricket::ICE_PWD_LENGTH)),
       can_start_(false),
       channel_was_writable_(false),
-      connect_attempts_left_(kMaxReconnectAttempts) {
+      connect_attempts_left_(kMaxReconnectAttempts),
+      weak_factory_(this) {
   DCHECK(!ice_username_fragment_.empty());
   DCHECK(!ice_password_.empty());
 }
 
 LibjingleTransport::~LibjingleTransport() {
   DCHECK(event_handler_);
 
   event_handler_->OnTransportDeleted(this);
 
   if (channel_.get()) {
@@ skipping 57 matching lines @@
       !(network_settings_.flags & NetworkSettings::NAT_TRAVERSAL_OUTGOING));
 
   channel_->Connect();
 
   --connect_attempts_left_;
 
   // Start reconnection timer.
   reconnect_timer_.Start(
       FROM_HERE, base::TimeDelta::FromSeconds(kReconnectDelaySeconds),
       this, &LibjingleTransport::TryReconnect);
+}
 
+void LibjingleTransport::NotifyConnected() {
   // Create net::Socket adapter for the P2PTransportChannel.
   scoped_ptr<jingle_glue::TransportChannelSocketAdapter> socket(
       new jingle_glue::TransportChannelSocketAdapter(channel_.get()));
   socket->SetOnDestroyedCallback(base::Bind(
       &LibjingleTransport::OnChannelDestroyed, base::Unretained(this)));
 
   Transport::ConnectedCallback callback = callback_;
   callback_.Reset();
   callback.Run(socket.PassAs<net::Socket>());
 }
@@ skipping 68 matching lines @@
   }
 
   event_handler_->OnTransportRouteChange(this, route);
 }
 
 void LibjingleTransport::OnWritableState(
     cricket::TransportChannel* channel) {
   DCHECK_EQ(channel, channel_.get());
 
   if (channel->writable()) {
-    channel_was_writable_ = true;
+    if (!channel_was_writable_) {
+      channel_was_writable_ = true;
+      base::ThreadTaskRunnerHandle::Get()->PostTask(
+          FROM_HERE,
+          base::Bind(&LibjingleTransport::NotifyConnected,
+                     weak_factory_.GetWeakPtr()));
+    }
     connect_attempts_left_ = kMaxReconnectAttempts;
     reconnect_timer_.Stop();
   } else if (!channel->writable() && channel_was_writable_) {
     reconnect_timer_.Reset();
     TryReconnect();
   }
 }
 
 void LibjingleTransport::OnChannelDestroyed() {
   if (is_connected()) {
@@ skipping 95 matching lines @@
     last_jingle_info_update_time_ = base::TimeTicks::Now();
 
   while (!on_jingle_info_callbacks_.empty()) {
     on_jingle_info_callbacks_.begin()->Run();
     on_jingle_info_callbacks_.pop_front();
   }
 }
 
 }  // namespace protocol
 }  // namespace remoting