Fix LibjingleTransport to notify about route changes only when connected.

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 <algorithm>
 
 #include "base/callback.h"
 #include "base/single_thread_task_runner.h"
@@ skipping 68 matching lines @@
   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
   // socket is destroyed.
   void OnChannelDestroyed();
 
+  void NotifyRouteChanged();
+
   // Tries to connect by restarting ICE. Called by |reconnect_timer_|.
   void TryReconnect();
 
   cricket::PortAllocator* port_allocator_;
   NetworkSettings network_settings_;
 
   std::string name_;
   EventHandler* event_handler_;
   Transport::ConnectedCallback callback_;
   std::string ice_username_fragment_;
@@ skipping 152 matching lines @@
 void LibjingleTransport::OnCandidateReady(
     cricket::TransportChannelImpl* channel,
     const cricket::Candidate& candidate) {
   DCHECK(CalledOnValidThread());
   event_handler_->OnTransportCandidate(this, candidate);
 }
 
 void LibjingleTransport::OnRouteChange(
     cricket::TransportChannel* channel,
     const cricket::Candidate& candidate) {
+  // Ignore notifications if the channel is not writable.
+  if (channel_->writable())
+    NotifyRouteChanged();
+}
+
+void LibjingleTransport::OnWritableState(
+    cricket::TransportChannel* channel) {
+  DCHECK_EQ(channel, channel_.get());
+
+  if (channel->writable()) {
+    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();
+
+    // Route change notifications are ignored when the |channel_| is not
+    // writable. Notify the event handler about the current route once the
+    // channel is writable.
+    NotifyRouteChanged();
+  } else if (!channel->writable() && channel_was_writable_) {
+    reconnect_timer_.Reset();
+    TryReconnect();
+  }
+}
+
+void LibjingleTransport::OnChannelDestroyed() {
+  if (is_connected()) {
+    // The connection socket is being deleted, so delete the transport too.
+    delete this;
+  }
+}
+
+void LibjingleTransport::NotifyRouteChanged() {
   TransportRoute route;
 
   DCHECK(channel_->best_connection());
   const cricket::Connection* connection = channel_->best_connection();
 
   // A connection has both a local and a remote candidate. For our purposes, the
   // route type is determined by the most indirect candidate type. For example:
   // it's possible for the local candidate be a "relay" type, while the remote
   // candidate is "local". In this case, we still want to report a RELAY route
   // type.
   static_assert(TransportRoute::DIRECT < TransportRoute::STUN &&
                 TransportRoute::STUN < TransportRoute::RELAY,
                 "Route type enum values are ordered by 'indirectness'");
   route.type = std::max(
       CandidateTypeToTransportRouteType(connection->local_candidate().type()),
       CandidateTypeToTransportRouteType(connection->remote_candidate().type()));
 
   if (!jingle_glue::SocketAddressToIPEndPoint(
-          candidate.address(), &route.remote_address)) {
+          connection->remote_candidate().address(), &route.remote_address)) {
     LOG(FATAL) << "Failed to convert peer IP address.";
   }
 
   const cricket::Candidate& local_candidate =
       channel_->best_connection()->local_candidate();
   if (!jingle_glue::SocketAddressToIPEndPoint(
           local_candidate.address(), &route.local_address)) {
     LOG(FATAL) << "Failed to convert local IP address.";
   }
 
   event_handler_->OnTransportRouteChange(this, route);
 }
 
-void LibjingleTransport::OnWritableState(
-    cricket::TransportChannel* channel) {
-  DCHECK_EQ(channel, channel_.get());
-
-  if (channel->writable()) {
-    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()) {
-    // The connection socket is being deleted, so delete the transport too.
-    delete this;
-  }
-}
-
 void LibjingleTransport::TryReconnect() {
   DCHECK(!channel_->writable());
 
   if (connect_attempts_left_ <= 0) {
     reconnect_timer_.Stop();
 
     // Notify the caller that ICE connection has failed - normally that will
     // terminate Jingle connection (i.e. the transport will be destroyed).
     event_handler_->OnTransportFailed(this);
     return;
@@ skipping 80 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