Propagate connection state from networking layer to UI.

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/single_thread_task_runner.h"
 #include "base/thread_task_runner_handle.h"
 #include "jingle/glue/channel_socket_adapter.h"
 #include "jingle/glue/pseudotcp_adapter.h"
@@ skipping 40 matching lines @@
   virtual void AddRemoteCandidate(const cricket::Candidate& candidate) OVERRIDE;
   virtual const std::string& name() const OVERRIDE;
   virtual bool is_connected() const OVERRIDE;
 
  private:
   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);
 
   void OnTcpConnected(int result);
   void OnAuthenticationDone(net::Error error,
                             scoped_ptr<net::StreamSocket> socket);
 
   void OnChannelDestroyed();
 
   void NotifyConnected(scoped_ptr<net::StreamSocket> socket);
   void NotifyConnectFailed();
 
@@ skipping 68 matching lines @@
   channel_.reset(new cricket::P2PTransportChannel(
       0, NULL, port_allocator_));
   channel_->SetIceUfrag(ice_username_fragment_);
   channel_->SetIcePwd(ice_password_);
   channel_->SignalRequestSignaling.connect(
       this, &LibjingleStreamTransport::OnRequestSignaling);
   channel_->SignalCandidateReady.connect(
       this, &LibjingleStreamTransport::OnCandidateReady);
   channel_->SignalRouteChange.connect(
       this, &LibjingleStreamTransport::OnRouteChange);
+  channel_->SignalWritableState.connect(
+      this, &LibjingleStreamTransport::OnWritableState);
   channel_->set_incoming_only(incoming_only_);
 
   channel_->Connect();
 
   // Create net::Socket adapter for the P2PTransportChannel.
   scoped_ptr<jingle_glue::TransportChannelSocketAdapter> channel_adapter(
       new jingle_glue::TransportChannelSocketAdapter(channel_.get()));
 
   channel_adapter->SetOnDestroyedCallback(base::Bind(
       &LibjingleStreamTransport::OnChannelDestroyed, base::Unretained(this)));
@@ skipping 72 matching lines @@
   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 LibjingleStreamTransport::OnWritableState(
+    cricket::TransportChannel* channel) {
+  event_handler_->OnTransportInactive(this, !channel->writable());

[Wez, 2012/07/16 18:51:23]

You're picking up whether a channel is "active" from whether or not it's
writable; that will work for UDP channels but if we ever re-enable TCP channels
then the channel will become un-writable when the TCP buffer is full, surely?

[Sergey Ulanov, 2012/07/17 01:17:17]

Libjingle marks a channel as not-writable when it failed to receive pings on
that channel for more than five seconds. pings are sent every second. It works
the same for both UDP and TCP-based connections.

+}
+
 void LibjingleStreamTransport::OnTcpConnected(int result) {
   DCHECK(CalledOnValidThread());
 
   if (result != net::OK) {
     NotifyConnectFailed();
     return;
   }
 
   authenticator_->SecureAndAuthenticate(
       socket_.PassAs<net::StreamSocket>(),
@@ skipping 99 matching lines @@
 }
 
 scoped_ptr<DatagramTransport>
 LibjingleTransportFactory::CreateDatagramTransport() {
   NOTIMPLEMENTED();
   return scoped_ptr<DatagramTransport>(NULL);
 }
 
 }  // namespace protocol
 }  // namespace remoting