Reports host version, host os and host os version for It2me Host.

remoting/host/register_support_host_request.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/host/register_support_host_request.h"
 
 #include <stdint.h>
 
 #include "base/bind.h"
 #include "base/callback_helpers.h"
 #include "base/logging.h"
 #include "base/message_loop/message_loop.h"
 #include "base/strings/string_number_conversions.h"
+#include "base/strings/stringize_macros.h"
 #include "base/time/time.h"
 #include "remoting/base/constants.h"
 #include "remoting/host/host_config.h"
+#include "remoting/host/host_details.h"
 #include "remoting/signaling/iq_sender.h"
 #include "remoting/signaling/jid_util.h"
 #include "remoting/signaling/signal_strategy.h"
 #include "remoting/signaling/signaling_address.h"
 #include "third_party/libjingle_xmpp/xmllite/xmlelement.h"
 #include "third_party/libjingle_xmpp/xmpp/constants.h"
 
 using buzz::QName;
 using buzz::XmlElement;
 
 namespace remoting {
 
 namespace {
 // Strings used in the request message we send to the bot.
 const char kRegisterQueryTag[] = "register-support-host";
 const char kPublicKeyTag[] = "public-key";
 const char kSignatureTag[] = "signature";
 const char kSignatureTimeAttr[] = "time";
+const char kHostVersionTag[] = "host-version";
+const char kHostOsNameTag[] = "host-os-name";
+const char kHostOsVersionTag[] = "host-os-version";
 
 // Strings used to parse responses received from the bot.
 const char kRegisterQueryResultTag[] = "register-support-host-result";
 const char kSupportIdTag[] = "support-id";
 const char kSupportIdLifetimeTag[] = "support-id-lifetime";
 }
 
 RegisterSupportHostRequest::RegisterSupportHostRequest(
     SignalStrategy* signal_strategy,
     scoped_refptr<RsaKeyPair> key_pair,
@@ skipping 32 matching lines @@
   }
 }
 
 bool RegisterSupportHostRequest::OnSignalStrategyIncomingStanza(
     const buzz::XmlElement* stanza) {
   return false;
 }
 
 std::unique_ptr<XmlElement>
 RegisterSupportHostRequest::CreateRegistrationRequest(const std::string& jid) {
-  std::unique_ptr<XmlElement> query(
-      new XmlElement(QName(kChromotingXmlNamespace, kRegisterQueryTag)));
-  XmlElement* public_key = new XmlElement(
+  auto query = base::MakeUnique<XmlElement>(
+      QName(kChromotingXmlNamespace, kRegisterQueryTag));
+
+  auto public_key = base::MakeUnique<XmlElement>(
       QName(kChromotingXmlNamespace, kPublicKeyTag));
   public_key->AddText(key_pair_->GetPublicKey());
-  query->AddElement(public_key);
+  query->AddElement(public_key.release());
+
   query->AddElement(CreateSignature(jid).release());
+
+  // Add host version.
+  auto host_version = base::MakeUnique<XmlElement>(
+      QName(kChromotingXmlNamespace, kHostVersionTag));
+  host_version->AddText(STRINGIZE(VERSION));
+  query->AddElement(host_version.release());
+
+  // Add host os name.
+  auto host_os_name = base::MakeUnique<XmlElement>(
+      QName(kChromotingXmlNamespace, kHostOsNameTag));
+  host_os_name->AddText(GetHostOperatingSystemName());
+  query->AddElement(host_os_name.release());
+
+  // Add host os version.
+  auto host_os_version = base::MakeUnique<XmlElement>(
+      QName(kChromotingXmlNamespace, kHostOsVersionTag));
+  host_os_version->AddText(GetHostOperatingSystemVersion());
+  query->AddElement(host_os_version.release());
+
   return query;
 }
 
 std::unique_ptr<XmlElement> RegisterSupportHostRequest::CreateSignature(
     const std::string& jid) {
   std::unique_ptr<XmlElement> signature_tag(
       new XmlElement(QName(kChromotingXmlNamespace, kSignatureTag)));
 
   int64_t time = static_cast<int64_t>(base::Time::Now().ToDoubleT());
   std::string time_str(base::Int64ToString(time));
@@ skipping 95 matching lines @@
   // Cleanup state before calling the callback.
   request_.reset();
   iq_sender_.reset();
   signal_strategy_->RemoveListener(this);
   signal_strategy_ = nullptr;
 
   base::ResetAndReturn(&callback_).Run(support_id, lifetime, error_message);
 }
 
 }  // namespace remoting