[Chromoting] Use google:remoting namespace to export remoting specific error codes

remoting/protocol/jingle_session.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/jingle_session.h"
 
 #include <stdint.h>
 
 #include <limits>
 #include <utility>
@@ skipping 222 matching lines @@
     LOG(ERROR) << "Failed to send a transport-info message";
   }
 }
 
 void JingleSession::Close(protocol::ErrorCode error) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   if (is_session_active()) {
     // Send session-terminate message with the appropriate error code.
     JingleMessage::Reason reason;
+    ErrorCode error_code = UNKNOWN_ERROR;

[Sergey Ulanov, 2016/06/02 09:26:04]

I think we want to set error_code for _all_ errors.

[Hzj_jie, 2016/06/02 22:00:19]

Done.

     switch (error) {
       case OK:
         reason = JingleMessage::SUCCESS;
         break;
       case SESSION_REJECTED:
+        reason = JingleMessage::DECLINE;
+        error_code = SESSION_REJECTED;
       case AUTHENTICATION_FAILED:
         reason = JingleMessage::DECLINE;
+        error_code = AUTHENTICATION_FAILED;
         break;
       case INVALID_ACCOUNT:
-        // TODO(zijiehe): Instead of using SECURITY_ERROR Jingle reason, add a
-        // new tag under crd namespace to export detail error reason to client.
-        reason = JingleMessage::SECURITY_ERROR;
+        reason = JingleMessage::DECLINE;
+        error_code = INVALID_ACCOUNT;
         break;
       case INCOMPATIBLE_PROTOCOL:
         reason = JingleMessage::INCOMPATIBLE_PARAMETERS;
         break;
       case HOST_OVERLOAD:
         reason = JingleMessage::CANCEL;
         break;
       case MAX_SESSION_LENGTH:
         reason = JingleMessage::EXPIRED;
         break;
       case HOST_CONFIGURATION_ERROR:
         reason = JingleMessage::FAILED_APPLICATION;
         break;
       default:
         reason = JingleMessage::GENERAL_ERROR;
     }
 
     JingleMessage message(peer_address_, JingleMessage::SESSION_TERMINATE,
                           session_id_);
     message.reason = reason;
+    message.error_code = error_code;

[Sergey Ulanov, 2016/06/02 09:26:04]

message.error_code = error; and remove error_code variable.

[Hzj_jie, 2016/06/02 22:00:19]

Done.

     SendMessage(message);
   }
 
   error_ = error;
 
   if (state_ != FAILED && state_ != CLOSED) {
     if (error != OK) {
       SetState(FAILED);
     } else {
       SetState(CLOSED);
@@ skipping 189 matching lines @@
 void JingleSession::OnTerminate(const JingleMessage& message,
                                 const ReplyCallback& reply_callback) {
   if (!is_session_active()) {
     LOG(WARNING) << "Received unexpected session-terminate message.";
     reply_callback.Run(JingleMessageReply::UNEXPECTED_REQUEST);
     return;
   }
 
   reply_callback.Run(JingleMessageReply::NONE);
 
-  switch (message.reason) {
-    case JingleMessage::SUCCESS:
-      if (state_ == CONNECTING) {
-        error_ = SESSION_REJECTED;
-      } else {
-        error_ = OK;
-      }
-      break;
-    case JingleMessage::DECLINE:
+  switch (message.error_code) {

[Sergey Ulanov, 2016/06/02 09:26:04]

You don't need this switch. 
Just replace it with error_ = message.error_code;

[Hzj_jie, 2016/06/02 22:00:19]

Done.

+    case SESSION_REJECTED:
+      // For backward compatibility, we still use AUTHENTICATION_FAILED for
+      // SESSION_REJECTED error.
       error_ = AUTHENTICATION_FAILED;
       break;
-    case JingleMessage::SECURITY_ERROR:
+    case AUTHENTICATION_FAILED:
+      error_ = AUTHENTICATION_FAILED;
+      break;
+    case INVALID_ACCOUNT:
       error_ = INVALID_ACCOUNT;
       break;
-    case JingleMessage::CANCEL:
-      error_ = HOST_OVERLOAD;
-      break;
-    case JingleMessage::EXPIRED:
-      error_ = MAX_SESSION_LENGTH;
-      break;
-    case JingleMessage::INCOMPATIBLE_PARAMETERS:
-      error_ = INCOMPATIBLE_PROTOCOL;
-      break;
-    case JingleMessage::FAILED_APPLICATION:
-      error_ = HOST_CONFIGURATION_ERROR;
-      break;
-    case JingleMessage::GENERAL_ERROR:
-      error_ = CHANNEL_CONNECTION_ERROR;
-      break;
     default:
-      error_ = UNKNOWN_ERROR;
+      switch (message.reason) {

[Sergey Ulanov, 2016/06/02 09:26:04]

switch inside a switch is hard for humans to parse

[Hzj_jie, 2016/06/02 22:00:19]

Done.

+        case JingleMessage::SUCCESS:
+          if (state_ == CONNECTING) {
+            error_ = SESSION_REJECTED;
+          } else {
+            error_ = OK;
+          }
+          break;
+        case JingleMessage::DECLINE:
+          error_ = AUTHENTICATION_FAILED;
+          break;
+        case JingleMessage::CANCEL:
+          error_ = HOST_OVERLOAD;
+          break;
+        case JingleMessage::EXPIRED:
+          error_ = MAX_SESSION_LENGTH;
+          break;
+        case JingleMessage::INCOMPATIBLE_PARAMETERS:
+          error_ = INCOMPATIBLE_PROTOCOL;
+          break;
+        case JingleMessage::FAILED_APPLICATION:
+          error_ = HOST_CONFIGURATION_ERROR;
+          break;
+        case JingleMessage::GENERAL_ERROR:
+          error_ = CHANNEL_CONNECTION_ERROR;
+          break;
+        default:
+          error_ = UNKNOWN_ERROR;
+      }
   }
 
   if (error_ != OK) {
     SetState(FAILED);
   } else {
     SetState(CLOSED);
   }
 }
 
 bool JingleSession::InitializeConfigFromDescription(
@@ skipping 76 matching lines @@
   }
 }
 
 bool JingleSession::is_session_active() {
   return state_ == CONNECTING || state_ == ACCEPTING || state_ == ACCEPTED ||
         state_ == AUTHENTICATING || state_ == AUTHENTICATED;
 }
 
 }  // namespace protocol
 }  // namespace remoting