Added gcdPrivate.getDeviceInfo function

chrome/browser/local_discovery/privetv3_session.cc

 // Copyright 2014 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 "chrome/browser/local_discovery/privetv3_session.h"
 
 #include "base/base64.h"
 #include "base/json/json_writer.h"
 #include "base/logging.h"
 #include "base/message_loop/message_loop.h"
@@ skipping 40 matching lines @@
 
 const int kUrlFetcherTimeoutSec = 30;
 
 GURL CreatePrivetURL(const std::string& path) {
   GURL url(kUrlPlaceHolder);
   GURL::Replacements replacements;
   replacements.SetPathStr(path);
   return url.ReplaceComponents(replacements);
 }
 
-template <typename T>
-class EnumToStringMap {
- public:
-  static std::string FindNameById(T id) {
-    for (const Element& m : kMap) {
-      if (m.id == id) {
-        DCHECK(m.name);
-        return m.name;
-      }
-    }
-    NOTREACHED();
-    return std::string();
-  }
-
-  static bool FindIdByName(const std::string& name, T* id) {
-    for (const Element& m : kMap) {
-      if (m.name && m.name == name) {
-        *id = m.id;
-        return true;
-      }
-    }
-    return false;
-  }
-
- private:
-  struct Element {
-    const T id;
-    const char* const name;
-  };
-  static const Element kMap[];
-};
-
 using PairingType = PrivetV3Session::PairingType;
 
-template <>
-const EnumToStringMap<PrivetV3Session::PairingType>::Element
-    EnumToStringMap<PrivetV3Session::PairingType>::kMap[] = {
-        {PairingType::PAIRING_TYPE_PINCODE, "pinCode"},
-        {PairingType::PAIRING_TYPE_EMBEDDEDCODE, "embeddedCode"},
-        {PairingType::PAIRING_TYPE_ULTRASOUND32, "ultrasound32"},
-        {PairingType::PAIRING_TYPE_AUDIBLE32, "audible32"},
-};
-
-template <typename T>
-std::string EnumToString(T id) {
-  return EnumToStringMap<T>::FindNameById(id);
-}
-
-template <typename T>
-bool StringToEnum(const std::string& name, T* id) {
-  return EnumToStringMap<T>::FindIdByName(name, id);
-}
-
 bool GetDecodedString(const base::DictionaryValue& response,
                       const std::string& key,
                       std::string* value) {
   std::string base64;
   return response.GetString(key, &base64) && base::Base64Decode(base64, value);
 }
 
 bool ContainsString(const base::DictionaryValue& dictionary,
                     const std::string& key,
                     const std::string& expected_value) {
@@ skipping 146 matching lines @@
   privet_auth_token_ = kPrivetV3AuthAnonymous;
 
   StartGetRequest(kPrivetInfoPath,
                   base::Bind(&PrivetV3Session::OnInfoDone,
                              weak_ptr_factory_.GetWeakPtr(), callback));
 }
 
 void PrivetV3Session::OnInfoDone(const InitCallback& callback,
                                  Result result,
                                  const base::DictionaryValue& response) {
-  std::vector<PairingType> pairing_types;
   if (result != Result::STATUS_SUCCESS)
-    return callback.Run(result, pairing_types);
+    return callback.Run(result, response);
 
   std::string version;
   if (!response.GetString(kPrivetV3InfoKeyVersion, &version) ||
       version != kPrivetV3InfoVersion) {
     LOG(ERROR) << "Response: " << response;
-    return callback.Run(Result::STATUS_SESSIONERROR, pairing_types);
+    return callback.Run(Result::STATUS_SESSIONERROR, response);
   }
 
   const base::DictionaryValue* authentication = nullptr;
   const base::ListValue* pairing = nullptr;
   if (!response.GetDictionary(kPrivetV3InfoKeyAuth, &authentication) ||
       !authentication->GetList(kPrivetV3KeyPairing, &pairing)) {
     LOG(ERROR) << "Response: " << response;
-    return callback.Run(Result::STATUS_SESSIONERROR, pairing_types);
+    return callback.Run(Result::STATUS_SESSIONERROR, response);
   }
 
   // The only supported crypto.
   if (!ContainsString(*authentication, kPrivetV3KeyCrypto,
                       kPrivetV3CryptoP224Spake2) ||
       !ContainsString(*authentication, kPrivetV3KeyMode, kPrivetV3KeyPairing)) {
     LOG(ERROR) << "Response: " << response;
-    return callback.Run(Result::STATUS_SESSIONERROR, pairing_types);
+    return callback.Run(Result::STATUS_SESSIONERROR, response);
   }
 
-  for (const base::Value* value : *pairing) {
-    std::string pairing_string;
-    PairingType pairing_type;
-    if (!value->GetAsString(&pairing_string) ||
-        !StringToEnum(pairing_string, &pairing_type)) {
-      continue;  // Skip unknown pairing.
-    }
-    pairing_types.push_back(pairing_type);
-  }
-
-  callback.Run(Result::STATUS_SUCCESS, pairing_types);
+  callback.Run(Result::STATUS_SUCCESS, response);
 }
 
 void PrivetV3Session::StartPairing(PairingType pairing_type,
                                    const ResultCallback& callback) {
   base::DictionaryValue input;
-  input.SetString(kPrivetV3KeyPairing, EnumToString(pairing_type));
+  input.SetString(kPrivetV3KeyPairing,
+                  extensions::api::gcd_private::ToString(pairing_type));
   input.SetString(kPrivetV3KeyCrypto, kPrivetV3CryptoP224Spake2);
 
   StartPostRequest(kPrivetV3PairingStartPath, input,
                    base::Bind(&PrivetV3Session::OnPairingStartDone,
                               weak_ptr_factory_.GetWeakPtr(), callback));
 }
 
 void PrivetV3Session::OnPairingStartDone(
     const ResultCallback& callback,
     Result result,
@@ skipping 165 matching lines @@
 void PrivetV3Session::Cancel() {
   // Cancel started unconfirmed sessions.
   if (session_id_.empty() || !fingerprint_.empty())
     return;
   base::DictionaryValue input;
   input.SetString(kPrivetV3KeySessionId, session_id_);
   StartPostRequest(kPrivetV3PairingCancelPath, input, MessageCallback());
 }
 
 }  // namespace local_discovery