Use Authenticator interface in Session and SessionManager

remoting/protocol/content_description.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/content_description.h"
 
-#include "base/base64.h"
 #include "base/logging.h"
 #include "base/string_number_conversions.h"
 #include "remoting/base/constants.h"
 #include "third_party/libjingle/source/talk/xmllite/xmlelement.h"
 
 using buzz::QName;
 using buzz::XmlElement;
 
 namespace remoting {
 namespace protocol {
 
 const char ContentDescription::kChromotingContentName[] = "chromoting";
 
 namespace {
 
 const char kDefaultNs[] = "";
 
 // Following constants are used to format session description in XML.
 const char kDescriptionTag[] = "description";
 const char kControlTag[] = "control";
 const char kEventTag[] = "event";
 const char kVideoTag[] = "video";
 const char kResolutionTag[] = "initial-resolution";
 const char kAuthenticationTag[] = "authentication";
-const char kCertificateTag[] = "certificate";
-const char kAuthTokenTag[] = "auth-token";
 
 const char kTransportAttr[] = "transport";
 const char kVersionAttr[] = "version";
 const char kCodecAttr[] = "codec";
 const char kWidthAttr[] = "width";
 const char kHeightAttr[] = "height";
 
 const char kStreamTransport[] = "stream";
 const char kDatagramTransport[] = "datagram";
 const char kSrtpTransport[] = "srtp";
@@ skipping 99 matching lines @@
     config->codec = ChannelConfig::CODEC_UNDEFINED;
   }
 
   return true;
 }
 
 }  // namespace
 
 ContentDescription::ContentDescription(
     const CandidateSessionConfig* candidate_config,
-    const std::string& auth_token,
-    const std::string& certificate)
+    const buzz::XmlElement* authenticator_message)
     : candidate_config_(candidate_config),
-      auth_token_(auth_token),
-      certificate_(certificate) {
+      authenticator_message_(authenticator_message) {
 }
 
 ContentDescription::~ContentDescription() { }
 
 // ToXml() creates content description for chromoting session. The
 // description looks as follows:
 //   <description xmlns="google:remoting">
 //     <control transport="stream" version="1" />
 //     <event transport="datagram" version="1" />
 //     <video transport="srtp" codec="vp8" version="1" />
 //     <initial-resolution width="800" height="600" />
 //     <authentication>
-//       <certificate>[BASE64 Encoded Certificate]</certificate>
-//       <auth-token>...</auth-token>  // IT2Me only.
+//      Authentication message created by Authenticator implementation.

[Wez, 2011/11/25 06:54:11]

nit: The word "authentication" seems superfluous here.

[Sergey Ulanov, 2011/11/28 18:55:16]

Done.

 //     </authentication>
 //   </description>
 //
 XmlElement* ContentDescription::ToXml() const {
   XmlElement* root = new XmlElement(
       QName(kChromotingXmlNamespace, kDescriptionTag), true);
 
   std::vector<ChannelConfig>::const_iterator it;
 
   for (it = config()->control_configs().begin();
@@ skipping 14 matching lines @@
   XmlElement* resolution_tag = new XmlElement(
       QName(kChromotingXmlNamespace, kResolutionTag));
   resolution_tag->AddAttr(QName(kDefaultNs, kWidthAttr),
                           base::IntToString(
                               config()->initial_resolution().width));
   resolution_tag->AddAttr(QName(kDefaultNs, kHeightAttr),
                           base::IntToString(
                               config()->initial_resolution().height));
   root->AddElement(resolution_tag);
 
-  if (!certificate().empty() || !auth_token().empty()) {
-    XmlElement* authentication_tag = new XmlElement(
-        QName(kChromotingXmlNamespace, kAuthenticationTag));
-
-    if (!certificate().empty()) {
-      XmlElement* certificate_tag = new XmlElement(
-          QName(kChromotingXmlNamespace, kCertificateTag));
-
-      std::string base64_cert;
-      if (!base::Base64Encode(certificate(), &base64_cert)) {
-        LOG(DFATAL) << "Cannot perform base64 encode on certificate";
-      }
-
-      certificate_tag->SetBodyText(base64_cert);
-      authentication_tag->AddElement(certificate_tag);
-    }
-
-    if (!auth_token().empty()) {
-      XmlElement* auth_token_tag = new XmlElement(
-          QName(kChromotingXmlNamespace, kAuthTokenTag));
-      auth_token_tag->SetBodyText(auth_token());
-      authentication_tag->AddElement(auth_token_tag);
-    }
-
-    root->AddElement(authentication_tag);
+  if (authenticator_message_.get()) {
+    DCHECK(authenticator_message_->Name() ==
+           QName(kChromotingXmlNamespace, kAuthenticationTag));
+    root->AddElement(new XmlElement(*authenticator_message_));
   }
 
   return root;
 }
 
 // static
 ContentDescription* ContentDescription::ParseXml(
     const XmlElement* element) {
   if (element->Name() == QName(kChromotingXmlNamespace, kDescriptionTag)) {
     scoped_ptr<CandidateSessionConfig> config(
@@ skipping 39 matching lines @@
       return NULL; // Resolution must always be specified.
     int width;
     int height;
     if (!base::StringToInt(child->Attr(QName(kDefaultNs, kWidthAttr)),
                            &width) ||
         !base::StringToInt(child->Attr(QName(kDefaultNs, kHeightAttr)),
                            &height)) {
       return NULL;
     }
     ScreenResolution resolution(width, height);
-    if (!resolution.IsValid()) {
+    if (!resolution.IsValid())
       return NULL;
-    }
 
     *config->mutable_initial_resolution() = resolution;
 
-    // Parse authentication information.
-    std::string certificate;
-    std::string auth_token;
+    scoped_ptr<XmlElement> authenticator_message;
     child = element->FirstNamed(QName(kChromotingXmlNamespace,
                                       kAuthenticationTag));
-    if (child) {
-      // Parse the certificate.
-      const XmlElement* cert_tag =
-          child->FirstNamed(QName(kChromotingXmlNamespace, kCertificateTag));
-      if (cert_tag) {
-        std::string base64_cert = cert_tag->BodyText();
-        if (!base::Base64Decode(base64_cert, &certificate)) {
-          LOG(ERROR) << "Failed to decode certificate received from the peer.";
-          return NULL;
-        }
-      }
+    if (child)
+      authenticator_message.reset(new XmlElement(*child));
 
-      // Parse auth-token.
-      const XmlElement* auth_token_tag =
-          child->FirstNamed(QName(kChromotingXmlNamespace, kAuthTokenTag));
-      if (auth_token_tag) {
-        auth_token = auth_token_tag->BodyText();
-      }
-    }
-
-    return new ContentDescription(config.release(), auth_token, certificate);
+    return new ContentDescription(
+        config.release(), authenticator_message.release());
   }
   LOG(ERROR) << "Invalid description: " << element->Str();
   return NULL;
 }
 
 }  // namespace protocol
 }  // namespace remoting