Parse termination reason and propagate the error to the Session interface.

remoting/protocol/jingle_messages.cc

 // Copyright (c) 2011 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/string_number_conversions.h"
 #include "remoting/base/constants.h"
 #include "remoting/protocol/content_description.h"
@@ skipping 11 matching lines @@
 const char kP2PTransportNamespace[] = "http://www.google.com/transport/p2p";
 
 namespace {
 
 const char kEmptyNamespace[] = "";
 const char kXmlNamespace[] = "http://www.w3.org/XML/1998/namespace";
 
 const char kSessionInitiateAction[] = "session-initiate";
 const char kSessionAcceptAction[] = "session-accept";
 const char kSessionTerminateAction[] = "session-terminate";
-const char kSessionRejectAction[] = "session-return";
 const char kTransportInfoAction[] = "transport-info";
 
 const int kPortMin = 1000;
 const int kPortMax = 65535;
 
 bool ParseCandidate(const buzz::XmlElement* element,
                     cricket::Candidate* candidate) {
   DCHECK(element->Name() == QName(kP2PTransportNamespace, "candidate"));
 
   const std::string& name = element->Attr(QName(kEmptyNamespace, "name"));
@@ skipping 55 matching lines @@
 
 }  // namespace
 
 // static
 bool JingleMessage::IsJingleMessage(const buzz::XmlElement* stanza) {
   return stanza->FirstNamed(QName(kJingleNamespace, "jingle")) != NULL;
 }
 
 JingleMessage::JingleMessage()
     : action(UNKNOWN_ACTION),
-      termination_reason(kJingleNamespace, "success") {
+      reason(UNKNOWN_REASON) {
 }
 
 JingleMessage::JingleMessage(
     const std::string& to_value,
     ActionType action_value,
     const std::string& sid_value)
     : to(to_value),
       action(action_value),
       sid(sid_value) {
 }
@@ skipping 16 matching lines @@
   std::string action_str = jingle_tag->Attr(QName(kEmptyNamespace, "action"));
   if (action_str.empty()) {
     *error = "action attribute is missing";
     return false;
   } else if (action_str == kSessionInitiateAction) {
     action = SESSION_INITIATE;
   } else if (action_str == kSessionAcceptAction) {
     action = SESSION_ACCEPT;
   } else if (action_str == kSessionTerminateAction) {
     action = SESSION_TERMINATE;
-  } else if (action_str == kSessionRejectAction) {
-    action = SESSION_REJECT;
   } else if (action_str == kTransportInfoAction) {
     action = TRANSPORT_INFO;
   } else {
     *error = "Unknown action " + action_str;
     return false;
   }
 
   sid = jingle_tag->Attr(QName(kEmptyNamespace, "sid"));
   if (sid.empty()) {
     *error = "sid attribute is missing";
     return false;
   }
 
-  if (action == SESSION_TERMINATE || action == SESSION_REJECT) {
-    const XmlElement* reason_tag =
-        jingle_tag->FirstNamed(QName(kJingleNamespace, "reason"));
-    if (reason_tag && reason_tag->FirstElement())
-      termination_reason = reason_tag->FirstElement()->Name();
+  const XmlElement* reason_tag =
+      jingle_tag->FirstNamed(QName(kJingleNamespace, "reason"));
+  if (reason_tag && reason_tag->FirstElement()) {
+    const QName& reason_qname(reason_tag->FirstElement()->Name());
+    if (reason_qname == QName(kJingleNamespace, "success")) {
+      reason = SUCCESS;
+    } else if (reason_qname == QName(kJingleNamespace, "decline")) {
+      reason = DECLINED;
+    } else if (reason_qname ==
+               QName(kJingleNamespace, "incompatible-parameters")) {
+      reason = INCOMPATIBLE_PARAMETERS;
+    } else {
+      reason = UNKNOWN_REASON;
+    }
+  }
+
+  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) {
@@ skipping 57 matching lines @@
   switch (action) {
     case SESSION_INITIATE:
       action_attr = kSessionInitiateAction;
       break;
     case SESSION_ACCEPT:
       action_attr = kSessionAcceptAction;
       break;
     case SESSION_TERMINATE:
       action_attr = kSessionTerminateAction;
       break;
-    case SESSION_REJECT:
-      action_attr = kSessionRejectAction;
-      break;
     case TRANSPORT_INFO:
       action_attr = kTransportInfoAction;
       break;
     default:
       NOTREACHED();
       break;
   }
   jingle_tag->AddAttr(QName(kEmptyNamespace, "action"), action_attr);
 
   if (action == SESSION_INITIATE)
     jingle_tag->AddAttr(QName(kEmptyNamespace, "initiator"), from);
 
-  if (action == SESSION_TERMINATE || action == SESSION_REJECT) {
+  if (reason != UNKNOWN_REASON) {
     XmlElement* reason_tag = new XmlElement(QName(kJingleNamespace, "reason"));
     jingle_tag->AddElement(reason_tag);
+    std::string reason_string;
+    switch (reason) {
+      case SUCCESS:
+        reason_string = "success";
+        break;
+      case DECLINED:
+        reason_string = "decline";
+        break;
+      case INCOMPATIBLE_PARAMETERS:
+        reason_string = "incompatible-parameters";
+        break;
+      default:
+        DLOG(FATAL) << "Invalid reason: " << reason;
+        reason_string = "success";
+    }

[simonmorris, 2011/09/26 23:33:44]

Factor out the map from Reason to string, so it doesn't
have to be coded identically here and in lines 161-170.

[Sergey Ulanov, 2011/09/27 01:09:46]

Done. Also refactored ActionType->string mapping.

+    reason_tag->AddElement(new XmlElement(
+        QName(kJingleNamespace, reason_string)));
+  }
 
-    reason_tag->AddElement(new XmlElement(termination_reason));
-  } else {
+  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");
 
     if (description.get())
       content_tag->AddElement(description->ToXml());
@@ skipping 101 matching lines @@
     text_elem->SetAttr(QName(kXmlNamespace, "lang"), "en");
     text_elem->SetBodyText(error_text);
     error->AddElement(text_elem);
   }
 
   return iq;
 }
 
 }  // namespace protocol
 }  // namespace remoting