Propagate connection state from networking layer to UI.

remoting/protocol/connection_to_host.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/connection_to_host.h"
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/location.h"
 #include "remoting/base/constants.h"
@@ skipping 191 matching lines @@
         CloseOnError(session_->error());
       }
       break;
   }
 }
 
 void ConnectionToHost::OnSessionRouteChange(const std::string& channel_name,
                                             const TransportRoute& route) {
 }
 
+void ConnectionToHost::OnSessionInactive(const std::string& channel_name,
+                                         bool inactive) {
+  if (channel_name == kVideoChannelName)
+    event_callback_->OnConnectionInactive(inactive);

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

You're basing the connection's "active" state purely on whether the video
channel is active; although it's the highest throughput channel, it's equally
disruptive for the event channel not to be "active", and if the web-app knew
that the event channel were inactive it could provide some transient indicator
of the fact in the UI. If you expose the list of "active" channels to the app in
each notification then you can provide more fine-grained indicators; otherwise,
include the states of all channels in the single session-active indication?

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

Changed it to set ready=false when any of the channels is not ready.

+}
+
 ConnectionToHost::State ConnectionToHost::state() const {
   return state_;
 }
 
 void ConnectionToHost::OnChannelInitialized(bool successful) {
   if (!successful) {
     LOG(ERROR) << "Failed to connect video channel";
     CloseOnError(CHANNEL_CONNECTION_ERROR);
     return;
   }
@@ skipping 42 matching lines @@
 
   if (state != state_) {
     state_ = state;
     error_ = error;
     event_callback_->OnConnectionState(state_, error_);
   }
 }
 
 }  // namespace protocol
 }  // namespace remoting