Improve handling of NONE transport in channel configuration.

remoting/protocol/content_description.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/content_description.h"
 
 #include "base/logging.h"
 #include "base/string_number_conversions.h"
 #include "remoting/base/constants.h"
 #include "remoting/protocol/authenticator.h"
@@ skipping 45 matching lines @@
 // e.g. for video channel:
 //    <video transport="stream" version="1" codec="vp8" />
 XmlElement* FormatChannelConfig(const ChannelConfig& config,
                                 const std::string& tag_name) {
   XmlElement* result = new XmlElement(
       QName(kChromotingXmlNamespace, tag_name));
 
   result->AddAttr(QName(kDefaultNs, kTransportAttr),
                   ValueToName(kTransports, config.transport));
 
-  result->AddAttr(QName(kDefaultNs, kVersionAttr),
-                  base::IntToString(config.version));
+  if (config.transport != ChannelConfig::TRANSPORT_NONE) {
+    result->AddAttr(QName(kDefaultNs, kVersionAttr),
+                    base::IntToString(config.version));
 
-  if (config.codec != ChannelConfig::CODEC_UNDEFINED) {
-    result->AddAttr(QName(kDefaultNs, kCodecAttr),
-                    ValueToName(kCodecs, config.codec));
+    if (config.codec != ChannelConfig::CODEC_UNDEFINED) {
+      result->AddAttr(QName(kDefaultNs, kCodecAttr),
+                      ValueToName(kCodecs, config.codec));
+    }
   }
 
   return result;
 }
 
 // Returns false if the element is invalid.
 bool ParseChannelConfig(const XmlElement* element, bool codec_required,
                         ChannelConfig* config) {
   if (!NameToValue(
           kTransports, element->Attr(QName(kDefaultNs, kTransportAttr)),
-          &config->transport) ||
-      !base::StringToInt(element->Attr(QName(kDefaultNs, kVersionAttr)),
-                         &config->version)) {
+          &config->transport)) {
     return false;
   }
 
-  if (codec_required) {
-    if (!NameToValue(kCodecs, element->Attr(QName(kDefaultNs, kCodecAttr)),
-                     &config->codec)) {
+  // Version is not required when transport="none".
+  if (config->transport != ChannelConfig::TRANSPORT_NONE) {
+    if (!base::StringToInt(element->Attr(QName(kDefaultNs, kVersionAttr)),
+                           &config->version)) {
       return false;
     }
+
+    // Codec is not required when transport="none".
+    if (codec_required) {
+      if (!NameToValue(kCodecs, element->Attr(QName(kDefaultNs, kCodecAttr)),
+                       &config->codec)) {
+        return false;
+      }
+    } else {
+      config->codec = ChannelConfig::CODEC_UNDEFINED;
+    }
   } else {
+    config->version = 0;
     config->codec = ChannelConfig::CODEC_UNDEFINED;
   }
 
   return true;
 }
 
 }  // namespace
 
 ContentDescription::ContentDescription(
     scoped_ptr<CandidateSessionConfig> config,
@@ skipping 80 matching lines @@
   while (child) {
     ChannelConfig channel_config;
     if (ParseChannelConfig(child, codec_required, &channel_config)) {
       configs->push_back(channel_config);
     }
     child = child->NextNamed(tag);
   }
   if (optional && configs->empty()) {
       // If there's no mention of the tag, implicitly assume
       // TRANSPORT_NONE for the channel.
-      configs->push_back(ChannelConfig(ChannelConfig::TRANSPORT_NONE,
-                                       kDefaultStreamVersion,
-                                       ChannelConfig::CODEC_VERBATIM));
+      configs->push_back(ChannelConfig());
   }
   return true;
 }
 
 // static
 scoped_ptr<ContentDescription> ContentDescription::ParseXml(
     const XmlElement* element) {
   if (element->Name() != QName(kChromotingXmlNamespace, kDescriptionTag)) {
     LOG(ERROR) << "Invalid description: " << element->Str();
     return scoped_ptr<ContentDescription>();
@@ skipping 15 matching lines @@
   const XmlElement* child = Authenticator::FindAuthenticatorMessage(element);
   if (child)
     authenticator_message.reset(new XmlElement(*child));
 
   return scoped_ptr<ContentDescription>(
       new ContentDescription(config.Pass(), authenticator_message.Pass()));
 }
 
 }  // namespace protocol
 }  // namespace remoting