Remove key exchange code from JingleSession.

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"
@@ skipping 13 matching lines @@
 const char kChromotingContentName[] = "chromoting";
 
 // 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 kMasterKeyTag[] = "master-key";
 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";
@@ skipping 101 matching lines @@
   }
 
   return true;
 }
 
 }  // namespace
 
 ContentDescription::ContentDescription(
     const CandidateSessionConfig* candidate_config,
     const std::string& auth_token,
-    const std::string& master_key,
     const std::string& certificate)
     : candidate_config_(candidate_config),
       auth_token_(auth_token),
-      master_key_(master_key),
       certificate_(certificate) {
 }
 
 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>
-//       <master-key>[master key encrypted with hosts
-//                    public key encoded with BASE64]</master-key>
 //       <auth-token>...</auth-token>  // IT2Me only.
 //     </authentication>
 //   </description>
 //
 XmlElement* ContentDescription::ToXml() const {
   XmlElement* root = new XmlElement(
       QName(kChromotingXmlNamespace, kDescriptionTag), true);
 
   std::vector<ChannelConfig>::const_iterator it;
 
@@ skipping 32 matching lines @@
 
       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 (!master_key().empty()) {
-      XmlElement* master_key_tag = new XmlElement(
-          QName(kChromotingXmlNamespace, kMasterKeyTag));
-
-      std::string master_key_base64;
-      if (!base::Base64Encode(master_key(), &master_key_base64)) {
-        LOG(DFATAL) << "Cannot perform base64 encode on master key";
-      }
-
-      master_key_tag->SetBodyText(master_key_base64);
-      authentication_tag->AddElement(master_key_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);
   }
 
@@ skipping 56 matching lines @@
     ScreenResolution resolution(width, height);
     if (!resolution.IsValid()) {
       return NULL;
     }
 
     *config->mutable_initial_resolution() = resolution;
 
     // Parse authentication information.
     std::string certificate;
     std::string auth_token;
-    std::string master_key;
     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;
         }
       }
 
-      // Parse master-key.
-      const XmlElement* master_key_tag =
-          child->FirstNamed(QName(kChromotingXmlNamespace, kMasterKeyTag));
-      if (master_key_tag) {
-        if (!base::Base64Decode(master_key_tag->BodyText(), &master_key)) {
-          LOG(ERROR) << "Failed to decode master-key received from the peer.";
-          return NULL;
-        }
-        master_key = master_key_tag->BodyText();
-      }
-
       // 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, master_key,
-                                  certificate);
+    return new ContentDescription(config.release(), auth_token, certificate);
   }
   LOG(ERROR) << "Invalid description: " << element->Str();
   return NULL;
 }
 
 }  // namespace protocol
 }  // namespace remoting