[Chromoting] Plugin message in JingleMessage

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 324 matching lines @@
     *error = "Unknown action " + action_str;
     return false;
   }
 
   sid = jingle_tag->Attr(QName(kEmptyNamespace, "sid"));
   if (sid.empty()) {
     *error = "sid attribute is missing";
     return false;
   }
 
+  const XmlElement* attachments_tag =
+      jingle_tag->FirstNamed(QName(kChromotingXmlNamespace, "attachments"));
+  if (attachments_tag) {
+    attachments.reset(new XmlElement(*attachments_tag));
+  } else {
+    attachments.reset();
+  }
+
   if (action == SESSION_INFO) {
     // session-info messages may contain arbitrary information not
     // defined by the Jingle protocol. We don't need to parse it.
     const XmlElement* child = jingle_tag->FirstElement();
+    // Plugin messages are action independent, which should not be considered as
+    // session-info.
+    if (child == attachments_tag) {
+      child = child->NextElement();
+    }
     if (child) {
       // session-info is allowed to be empty.
       info.reset(new XmlElement(*child));
     } else {
-      info.reset(nullptr);
+      info.reset();
     }
     return true;
   }
 
   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->BodyText().empty()) {
     if (!ParseErrorCode(error_code_tag->BodyText(), &error_code)) {
       LOG(WARNING) << "Unknown error-code received "
                    << error_code_tag->BodyText();
       error_code = UNKNOWN_ERROR;
     }
   }
 
-  if (action == SESSION_TERMINATE)
+  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(kWebrtcTransportNamespace, "transport"));
   if (webrtc_transport_tag) {
     transport_info.reset(new buzz::XmlElement(*webrtc_transport_tag));
   }
 
-  description.reset(nullptr);
+  description.reset();
   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";
       return false;
     }
 
     description = ContentDescription::ParseXml(description_tag,
                                                webrtc_transport_tag != nullptr);
@@ skipping 22 matching lines @@
   root->SetAttr(QName(kEmptyNamespace, "type"), "set");
 
   XmlElement* jingle_tag =
       new XmlElement(QName(kJingleNamespace, "jingle"), true);
   root->AddElement(jingle_tag);
   jingle_tag->AddAttr(QName(kEmptyNamespace, "sid"), sid);
   SetAddress(root.get(), jingle_tag, to, false);
   SetAddress(root.get(), jingle_tag, from, true);
 
   const char* action_attr = ValueToName(kActionTypes, action);
-  if (!action_attr)
+  if (!action_attr) {
     LOG(FATAL) << "Invalid action value " << action;
+  }
   jingle_tag->AddAttr(QName(kEmptyNamespace, "action"), action_attr);
 
+  if (attachments) {
+    jingle_tag->AddElement(new XmlElement(*attachments));
+  }
+
   if (action == SESSION_INFO) {
-    if (info.get())
+    if (info.get()) {
       jingle_tag->AddElement(new XmlElement(*info.get()));
+    }
     return root;
   }
 
-  if (action == SESSION_INITIATE)
+  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);
     reason_tag->AddElement(new XmlElement(
         QName(kJingleNamespace, ValueToName(kReasons, reason))));
 
     if (error_code != UNKNOWN_ERROR) {
       XmlElement* error_code_tag =
           new XmlElement(QName(kChromotingXmlNamespace, "error-code"));
       jingle_tag->AddElement(error_code_tag);
       error_code_tag->SetBodyText(ErrorCodeToString(error_code));
     }
   }
 
   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)
+    if (description) {
       content_tag->AddElement(description->ToXml());
+    }
 
     if (transport_info) {
       content_tag->AddElement(new XmlElement(*transport_info));
     } else if (description && description->config()->webrtc_supported()) {
       content_tag->AddElement(
           new XmlElement(QName(kWebrtcTransportNamespace, "transport")));
     }
   }
 
   return root;
@@ skipping 76 matching lines @@
       name = QName(kJabberNamespace, "unexpected-request");
       break;
     case UNSUPPORTED_INFO:
       type = "modify";
       name = QName(kJabberNamespace, "feature-not-implemented");
       break;
     default:
       NOTREACHED();
   }
 
-  if (!text.empty())
+  if (!text.empty()) {
     error_text = text;
+  }
 
   error->SetAttr(QName(kEmptyNamespace, "type"), type);
 
   // If the error name is not in the standard namespace, we have
   // to first add some error from that namespace.
   if (name.Namespace() != kJabberNamespace) {
     error->AddElement(
         new buzz::XmlElement(QName(kJabberNamespace, "undefined-condition")));
   }
   error->AddElement(new buzz::XmlElement(name));
 
   if (!error_text.empty()) {
     // It's okay to always use English here. This text is for
     // debugging purposes only.
     buzz::XmlElement* text_elem =
             new buzz::XmlElement(QName(kJabberNamespace, "text"));
     text_elem->SetAttr(QName(kXmlNamespace, "lang"), "en");
     text_elem->SetBodyText(error_text);
     error->AddElement(text_elem);
   }
 
   return iq;
 }
 
 IceTransportInfo::IceTransportInfo() {}
 IceTransportInfo::~IceTransportInfo() {}
 
 bool IceTransportInfo::ParseXml(
     const buzz::XmlElement* element) {
-  if (element->Name() != QName(kIceTransportNamespace, "transport"))
+  if (element->Name() != QName(kIceTransportNamespace, "transport")) {
     return false;
+  }
 
   ice_credentials.clear();
   candidates.clear();
 
   QName qn_credentials(kIceTransportNamespace, "credentials");
   for (const XmlElement* credentials_tag = element->FirstNamed(qn_credentials);
        credentials_tag;
        credentials_tag = credentials_tag->NextNamed(qn_credentials)) {
     IceTransportInfo::IceCredentials credentials;
-    if (!ParseIceCredentials(credentials_tag, &credentials))
+    if (!ParseIceCredentials(credentials_tag, &credentials)) {
       return false;
+    }
     ice_credentials.push_back(credentials);
   }
 
   QName qn_candidate(kIceTransportNamespace, "candidate");
   for (const XmlElement* candidate_tag = element->FirstNamed(qn_candidate);
        candidate_tag; candidate_tag = candidate_tag->NextNamed(qn_candidate)) {
     IceTransportInfo::NamedCandidate candidate;
-    if (!ParseIceCandidate(candidate_tag, &candidate))
+    if (!ParseIceCandidate(candidate_tag, &candidate)) {
       return false;
+    }
     candidates.push_back(candidate);
   }
 
   return true;
 }
 
 std::unique_ptr<buzz::XmlElement> IceTransportInfo::ToXml() const {
   std::unique_ptr<buzz::XmlElement> result(
       new XmlElement(QName(kIceTransportNamespace, "transport"), true));
   for (const IceCredentials& credentials : ice_credentials) {
     result->AddElement(FormatIceCredentials(credentials));
   }
   for (const NamedCandidate& candidate : candidates) {
     result->AddElement(FormatIceCandidate(candidate));
   }
   return result;
 }
 
 }  // namespace protocol
 }  // namespace remoting