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

remoting/protocol/jingle_messages.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_messages.h"
 
 #include "base/logging.h"
 #include "base/strings/string_number_conversions.h"
 #include "remoting/base/constants.h"
 #include "remoting/protocol/content_description.h"
 #include "remoting/protocol/name_value_map.h"
 #include "third_party/webrtc/libjingle/xmllite/xmlelement.h"
 
 using buzz::QName;
 using buzz::XmlElement;
 
 namespace remoting {
 namespace protocol {
 
 namespace {
 
 const char kJabberNamespace[] = "jabber:client";
 const char kJingleNamespace[] = "urn:xmpp:jingle:1";
 
+const char kRemotingNamespace[] = "google:remoting";

[Sergey Ulanov, 2016/06/01 08:52:47]

We already have kChromotingXmlNamespace in remoting/base/constants.h

[Hzj_jie, 2016/06/01 23:56:13]

Done.

+
 // Namespace for transport messages when using standard ICE.
 const char kIceTransportNamespace[] = "google:remoting:ice";
 
 const char kWebrtcTransportNamespace[] = "google:remoting:webrtc";
 
 const char kEmptyNamespace[] = "";
 const char kXmlNamespace[] = "http://www.w3.org/XML/1998/namespace";
 
 const int kPortMin = 1000;
 const int kPortMax = 65535;
 
 const NameMapElement<SignalingAddress::Channel> kChannelTypes[] = {
     {SignalingAddress::Channel::LCS, "lcs"},
     {SignalingAddress::Channel::XMPP, "xmpp"},
 };
 
 const NameMapElement<JingleMessage::ActionType> kActionTypes[] = {
   { JingleMessage::SESSION_INITIATE, "session-initiate" },
   { JingleMessage::SESSION_ACCEPT, "session-accept" },
   { JingleMessage::SESSION_TERMINATE, "session-terminate" },
   { JingleMessage::SESSION_INFO, "session-info" },
   { JingleMessage::TRANSPORT_INFO, "transport-info" },
 };
 
 const NameMapElement<JingleMessage::Reason> kReasons[] = {
   { JingleMessage::SUCCESS, "success" },
   { JingleMessage::DECLINE, "decline" },
-  { JingleMessage::SECURITY_ERROR, "security-error" },
   { JingleMessage::CANCEL, "cancel" },
   { JingleMessage::EXPIRED, "expired" },
   { JingleMessage::GENERAL_ERROR, "general-error" },
   { JingleMessage::FAILED_APPLICATION, "failed-application" },
   { JingleMessage::INCOMPATIBLE_PARAMETERS, "incompatible-parameters" },
 };
 
+const NameMapElement<JingleMessage::ErrorCode> kErrorCodes[] = {

[Sergey Ulanov, 2016/06/01 08:52:47]

We already have ErrorCodeToString() in errors.cc. It will need to be rewritten
to use NameToValue() and ValueToName()

[Hzj_jie, 2016/06/01 23:56:13]

Done.

+  { JingleMessage::ErrorCode::SESSION_REJECTED, "session-rejected" },
+  { JingleMessage::ErrorCode::AUTHENTICATION_FAILED, "authentication-failed" },
+  { JingleMessage::ErrorCode::INVALID_ACCOUNT, "invalid-account" },
+};
+
 bool ParseIceCredentials(const buzz::XmlElement* element,
                          IceTransportInfo::IceCredentials* credentials) {
   DCHECK(element->Name() == QName(kIceTransportNamespace, "credentials"));
 
   const std::string& channel = element->Attr(QName(kEmptyNamespace, "channel"));
   const std::string& ufrag =
       element->Attr(QName(kEmptyNamespace, "ufrag"));
   const std::string& password =
       element->Attr(QName(kEmptyNamespace, "password"));
 
@@ skipping 266 matching lines @@
 
   const XmlElement* reason_tag =
       jingle_tag->FirstNamed(QName(kJingleNamespace, "reason"));
   if (reason_tag && reason_tag->FirstElement()) {
     if (!NameToValue(kReasons, reason_tag->FirstElement()->Name().LocalPart(),
                      &reason)) {
       reason = UNKNOWN_REASON;
     }
   }
 
+  const XmlElement* error_code_tag =
+      jingle_tag->FirstNamed(QName(kRemotingNamespace, "error-code"));
+  if (error_code_tag && error_code_tag->FirstElement()) {
+    if (!NameToValue(kErrorCodes,
+                     error_code_tag->FirstElement()->Name().LocalPart(),
+                     &error_code)) {
+      error_code = ErrorCode::UNKNOWN;
+    }
+  }
+
   if (action == SESSION_TERMINATE)
     return true;
 
   const XmlElement* content_tag =
       jingle_tag->FirstNamed(QName(kJingleNamespace, "content"));
   if (!content_tag) {
     *error = "content tag is missing";
     return false;
   }
 
   std::string content_name = content_tag->Attr(QName(kEmptyNamespace, "name"));
   if (content_name != ContentDescription::kChromotingContentName) {
     *error = "Unexpected content name: " + content_name;
     return false;
   }
 
   const XmlElement* webrtc_transport_tag = content_tag->FirstNamed(
-      QName("google:remoting:webrtc", "transport"));
+      QName(kWebrtcTransportNamespace, "transport"));
   if (webrtc_transport_tag) {
     transport_info.reset(new buzz::XmlElement(*webrtc_transport_tag));
   }
 
   description.reset(nullptr);
   if (action == SESSION_INITIATE || action == SESSION_ACCEPT) {
     const XmlElement* description_tag = content_tag->FirstNamed(
         QName(kChromotingXmlNamespace, "description"));
     if (!description_tag) {
       *error = "Missing chromoting content description";
@@ skipping 43 matching lines @@
       jingle_tag->AddElement(new XmlElement(*info.get()));
     return root;
   }
 
   if (action == SESSION_INITIATE)
     jingle_tag->AddAttr(QName(kEmptyNamespace, "initiator"), initiator);
 
   if (reason != UNKNOWN_REASON) {
     XmlElement* reason_tag = new XmlElement(QName(kJingleNamespace, "reason"));
     jingle_tag->AddElement(reason_tag);
-    const char* reason_string =
-        ValueToName(kReasons, reason);
+    const char* reason_string = ValueToName(kReasons, reason);
     if (!reason_string)
       LOG(FATAL) << "Invalid reason: " << reason;
     reason_tag->AddElement(new XmlElement(
         QName(kJingleNamespace, reason_string)));
+
+    if (error_code != ErrorCode::UNKNOWN) {
+      XmlElement* error_code_tag =
+          new XmlElement(QName(kRemotingNamespace, "error-code"));
+      jingle_tag->AddElement(error_code_tag);
+      const char* error_code_string = ValueToName(kErrorCodes, error_code);
+      if (!error_code_string) {
+        LOG(FATAL) << "Invalid error code: " << static_cast<int>(error_code);
+      }
+      error_code_tag->AddElement(new XmlElement(
+          QName(kRemotingNamespace, error_code_string)));
+    }
   }
 
   if (action != SESSION_TERMINATE) {
     XmlElement* content_tag =
         new XmlElement(QName(kJingleNamespace, "content"));
     jingle_tag->AddElement(content_tag);
 
     content_tag->AddAttr(QName(kEmptyNamespace, "name"),
                          ContentDescription::kChromotingContentName);
     content_tag->AddAttr(QName(kEmptyNamespace, "creator"), "initiator");
@@ skipping 158 matching lines @@
     result->AddElement(FormatIceCredentials(credentials));
   }
   for (const NamedCandidate& candidate : candidates) {
     result->AddElement(FormatIceCandidate(candidate));
   }
   return result;
 }
 
 }  // namespace protocol
 }  // namespace remoting