Cleanup error handling in the client plugin.

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 "base/message_loop_proxy.h"
 #include "remoting/base/constants.h"
 #include "remoting/jingle_glue/javascript_signal_strategy.h"
 #include "remoting/jingle_glue/xmpp_signal_strategy.h"
 #include "remoting/protocol/auth_util.h"
 #include "remoting/protocol/authenticator.h"
 #include "remoting/protocol/client_control_dispatcher.h"
 #include "remoting/protocol/client_event_dispatcher.h"
 #include "remoting/protocol/client_stub.h"
+#include "remoting/protocol/errors.h"
 #include "remoting/protocol/jingle_session_manager.h"
 #include "remoting/protocol/pepper_transport_factory.h"
 #include "remoting/protocol/video_reader.h"
 #include "remoting/protocol/video_stub.h"
 #include "remoting/protocol/util.h"
 
 namespace remoting {
 namespace protocol {
 
 ConnectionToHost::ConnectionToHost(
@@ skipping 78 matching lines @@
 
 void ConnectionToHost::OnSignalStrategyStateChange(
     SignalStrategy::State state) {
   DCHECK(message_loop_->BelongsToCurrentThread());
   DCHECK(event_callback_);
 
   if (state == SignalStrategy::CONNECTED) {
     VLOG(1) << "Connected as: " << signal_strategy_->GetLocalJid();
   } else if (state == SignalStrategy::DISCONNECTED) {
     VLOG(1) << "Connection closed.";
-    CloseOnError(NETWORK_FAILURE);
+    CloseOnError(SIGNALING_ERROR);
   }
 }
 
 void ConnectionToHost::OnSessionManagerReady() {
   DCHECK(message_loop_->BelongsToCurrentThread());
 
   // After SessionManager is initialized we can try to connect to the host.
   scoped_ptr<CandidateSessionConfig> candidate_config =
       CandidateSessionConfig::CreateDefault();
   session_ = session_manager_->Connect(
@@ skipping 41 matching lines @@
       event_dispatcher_->Init(session_.get(), base::Bind(
           &ConnectionToHost::OnChannelInitialized, base::Unretained(this)));
       break;
 
     case Session::CLOSED:
       CloseChannels();
       SetState(CLOSED, OK);
       break;
 
     case Session::FAILED:
-      switch (session_->error()) {
-        case Session::PEER_IS_OFFLINE:
-          CloseOnError(HOST_IS_OFFLINE);
-          break;
-        case Session::SESSION_REJECTED:
-        case Session::AUTHENTICATION_FAILED:
-          CloseOnError(SESSION_REJECTED);
-          break;
-        case Session::INCOMPATIBLE_PROTOCOL:
-          CloseOnError(INCOMPATIBLE_PROTOCOL);
-          break;
-        case Session::CHANNEL_CONNECTION_ERROR:
-        case Session::UNKNOWN_ERROR:
-          CloseOnError(NETWORK_FAILURE);
-          break;
-        case Session::OK:
-          DLOG(FATAL) << "Error code isn't set";
-          CloseOnError(NETWORK_FAILURE);
+      // If we were connected then treat signaling timeout error as if
+      // the connection was closed by the peer.
+      //
+      // TODO(sergeyu): This logic belongs to the webapp, but we
+      // currently don't expose this error code to the webapp, and it
+      // would be hard to add it because client plugin and webapp
+      // versions may not be in sync. It should be easy to do after we
+      // are finished moving the client plugin to NaCl.
+      if (state_ == CONNECTED && session_->error() == SIGNALING_TIMEOUT) {
+        CloseChannels();
+        SetState(CLOSED, OK);
+      } else {
+        CloseOnError(session_->error());
       }
       break;
   }
 }
 
 void ConnectionToHost::OnChannelInitialized(bool successful) {
   if (!successful) {
     LOG(ERROR) << "Failed to connect video channel";
-    CloseOnError(NETWORK_FAILURE);
+    CloseOnError(CHANNEL_CONNECTION_ERROR);
     return;
   }
 
   NotifyIfChannelsReady();
 }
 
 void ConnectionToHost::NotifyIfChannelsReady() {
   if (control_dispatcher_.get() && control_dispatcher_->is_connected() &&
       event_dispatcher_.get() && event_dispatcher_->is_connected() &&
       video_reader_.get() && video_reader_->is_connected() &&
       state_ == CONNECTING) {
     // Start forwarding input events to |event_dispatcher_|.
     event_forwarder_.set_input_stub(event_dispatcher_.get());
     SetState(CONNECTED, OK);
   }
 }
 
-void ConnectionToHost::CloseOnError(Error error) {
+void ConnectionToHost::CloseOnError(ErrorCode error) {
   CloseChannels();
   SetState(FAILED, error);
 }
 
 void ConnectionToHost::CloseChannels() {
   control_dispatcher_.reset();
   event_dispatcher_.reset();
   event_forwarder_.set_input_stub(NULL);
   video_reader_.reset();
 }
 
-void ConnectionToHost::SetState(State state, Error error) {
+void ConnectionToHost::SetState(State state, ErrorCode error) {
   DCHECK(message_loop_->BelongsToCurrentThread());
   // |error| should be specified only when |state| is set to FAILED.
   DCHECK(state == FAILED || error == OK);
 
   if (state != state_) {
     state_ = state;
     error_ = error;
     event_callback_->OnConnectionState(state_, error_);
   }
 }
 
 }  // namespace protocol
 }  // namespace remoting