[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"
@@ skipping 31 matching lines @@
   { 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" },
 };
 
 bool ParseIceCredentials(const buzz::XmlElement* element,
                          IceTransportInfo::IceCredentials* credentials) {
   DCHECK(element->Name() == QName(kIceTransportNamespace, "credentials"));
@@ skipping 273 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(kChromotingXmlNamespace, "error-code"));
+  if (error_code_tag && error_code_tag->FirstElement()) {
+    if (!NameToValue(kErrorCodes,
+                     error_code_tag->FirstElement()->Name().LocalPart(),
+                     &error_code)) {
+      error_code = UNKNOWN_ERROR;

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

log a warning that the error code wasn't recognized.

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

Done.

+    }
+  }
+
   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 != UNKNOWN_ERROR) {
+      XmlElement* error_code_tag =
+          new XmlElement(QName(kChromotingXmlNamespace, "error-code"));
+      jingle_tag->AddElement(error_code_tag);
+      const char* error_code_string = ValueToName(kErrorCodes, error_code);
+      if (!error_code_string) {

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

replace with DCHECK(error_code_string)

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

Done.

+        LOG(FATAL) << "Invalid error code: " << static_cast<int>(error_code);
+      }
+      error_code_tag->AddElement(new XmlElement(

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

I don't think we want to add the error as element. Insert it as text.
I.e. it should be <error-code>PEER_IS_OFFLINE</error-code> instead of
<error-code><PEER_IS_OFFLINE/></error-code>

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

I used to implement as a text, but I found it's not a good idea. Do we treat
<error-code> PEER_IS_OFFLINE</error-code> and
<error-code>
    PEER_IS_OFFLINE
</error-code>
the same as <error-code>PEER_IS_OFFLINE</error-code>.
I did not see libjingle implements whiteSpace=collapsed scenario, and there is
also no whiteSpace=collapsed defined in our Xml output, which makes us need to
do trim and collapse ourselves.

And current solution is also consistent with other jingle errors.

[Sergey Ulanov, 2016/06/03 08:43:22]

I don't see how that can be a problem. When we generate
<error-code>FOO</error-code> we should get <error-code>FOO</error-code> on the
other end. If whitespace gets inserted there somehow it's a bug. There are other
places where we depend on whitespace not being inserted in random places. Beside
that it's easy to trim the whitepsace if we necessary. And if we really wanted
to be consistent with the Jingle's reason codes, then it would need to be
<rem:foo-error> instead of <rem:error-code>FOO_ERROR</rem:error-code>

[Hzj_jie, 2016/06/03 21:46:33]

Done.

+          QName(kChromotingXmlNamespace, 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