json_schema_compiler: Use std::vector<char> for binary values.

chrome/browser/extensions/api/easy_unlock_private/easy_unlock_private_api.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/extensions/api/easy_unlock_private/easy_unlock_private_api.h"
 
 #include <vector>
 
 #include "base/bind.h"
 #include "base/lazy_instance.h"
@@ skipping 329 matching lines @@
       base::Bind(&EasyUnlockPrivatePerformECDHKeyAgreementFunction::OnData,
                  this));
   return true;
 }
 
 void EasyUnlockPrivatePerformECDHKeyAgreementFunction::OnData(
     const std::string& secret_key) {
   // TODO(tbarzic): Improve error handling.
   if (!secret_key.empty()) {
     results_ = easy_unlock_private::PerformECDHKeyAgreement::Results::Create(
-        secret_key);
+        std::vector<char>(secret_key.begin(), secret_key.end()));
   }
   SendResponse(true);
 }
 
 EasyUnlockPrivateGenerateEcP256KeyPairFunction::
 EasyUnlockPrivateGenerateEcP256KeyPairFunction() {}
 
 EasyUnlockPrivateGenerateEcP256KeyPairFunction::
 ~EasyUnlockPrivateGenerateEcP256KeyPairFunction() {}
 
 bool EasyUnlockPrivateGenerateEcP256KeyPairFunction::RunAsync() {
   GetCryptoDelegate(browser_context())->GenerateEcP256KeyPair(
       base::Bind(&EasyUnlockPrivateGenerateEcP256KeyPairFunction::OnData,
                  this));
   return true;
 }
 
 void EasyUnlockPrivateGenerateEcP256KeyPairFunction::OnData(
     const std::string& private_key,
     const std::string& public_key) {
   // TODO(tbarzic): Improve error handling.
   if (!public_key.empty() && !private_key.empty()) {
     results_ = easy_unlock_private::GenerateEcP256KeyPair::Results::Create(
-        public_key, private_key);
+        std::vector<char>(public_key.begin(), public_key.end()),
+        std::vector<char>(private_key.begin(), private_key.end()));
   }
   SendResponse(true);
 }
 
 EasyUnlockPrivateCreateSecureMessageFunction::
 EasyUnlockPrivateCreateSecureMessageFunction() {}
 
 EasyUnlockPrivateCreateSecureMessageFunction::
 ~EasyUnlockPrivateCreateSecureMessageFunction() {}
 
 bool EasyUnlockPrivateCreateSecureMessageFunction::RunAsync() {
   scoped_ptr<easy_unlock_private::CreateSecureMessage::Params> params =
       easy_unlock_private::CreateSecureMessage::Params::Create(*args_);
   EXTENSION_FUNCTION_VALIDATE(params);
 
   GetCryptoDelegate(browser_context())->CreateSecureMessage(
       *params,
       base::Bind(&EasyUnlockPrivateCreateSecureMessageFunction::OnData,
                  this));
   return true;
 }
 
 void EasyUnlockPrivateCreateSecureMessageFunction::OnData(
     const std::string& message) {
   // TODO(tbarzic): Improve error handling.
   if (!message.empty()) {
     results_ = easy_unlock_private::CreateSecureMessage::Results::Create(
-        message);
+        std::vector<char>(message.begin(), message.end()));
   }
   SendResponse(true);
 }
 
 EasyUnlockPrivateUnwrapSecureMessageFunction::
 EasyUnlockPrivateUnwrapSecureMessageFunction() {}
 
 EasyUnlockPrivateUnwrapSecureMessageFunction::
 ~EasyUnlockPrivateUnwrapSecureMessageFunction() {}
 
 bool EasyUnlockPrivateUnwrapSecureMessageFunction::RunAsync() {
   scoped_ptr<easy_unlock_private::UnwrapSecureMessage::Params> params =
       easy_unlock_private::UnwrapSecureMessage::Params::Create(*args_);
   EXTENSION_FUNCTION_VALIDATE(params);
 
   GetCryptoDelegate(browser_context())->UnwrapSecureMessage(
       *params,
       base::Bind(&EasyUnlockPrivateUnwrapSecureMessageFunction::OnData,
                  this));
   return true;
 }
 
 void EasyUnlockPrivateUnwrapSecureMessageFunction::OnData(
     const std::string& data) {
   // TODO(tbarzic): Improve error handling.
-  if (!data.empty())
-    results_ = easy_unlock_private::UnwrapSecureMessage::Results::Create(data);
+  if (!data.empty()) {
+    results_ = easy_unlock_private::UnwrapSecureMessage::Results::Create(
+        std::vector<char>(data.begin(), data.end()));
+  }
   SendResponse(true);
 }
 
 EasyUnlockPrivateSeekBluetoothDeviceByAddressFunction::
     EasyUnlockPrivateSeekBluetoothDeviceByAddressFunction() {}
 
 EasyUnlockPrivateSeekBluetoothDeviceByAddressFunction::
     ~EasyUnlockPrivateSeekBluetoothDeviceByAddressFunction() {}
 
 bool EasyUnlockPrivateSeekBluetoothDeviceByAddressFunction::RunAsync() {
@@ skipping 176 matching lines @@
       EasyUnlockService::Get(profile)->GetChallenge();
   if (!challenge.empty() && !params->nonce.empty()) {
     EasyUnlockTpmKeyManager* key_manager =
         EasyUnlockTpmKeyManagerFactory::GetInstance()->Get(profile);
     if (!key_manager) {
       SetError("No EasyUnlockTpmKeyManager.");
       return false;
     }
     key_manager->SignUsingTpmKey(
         EasyUnlockService::Get(profile)->GetUserEmail(),
-        params->nonce,
-        base::Bind(&EasyUnlockPrivateGetSignInChallengeFunction::OnDone,
-                   this,
+        std::string(params->nonce.begin(), params->nonce.end()),
+        base::Bind(&EasyUnlockPrivateGetSignInChallengeFunction::OnDone, this,
                    challenge));
   } else {
     OnDone(challenge, std::string());
   }
   return true;
 #else  // if !defined(OS_CHROMEOS)
   SetError("Sign-in not supported.");
   return false;
 #endif  // defined(OS_CHROMEOS)
 }
 
 void EasyUnlockPrivateGetSignInChallengeFunction::OnDone(
     const std::string& challenge,
     const std::string& signed_nonce) {
   results_ = easy_unlock_private::GetSignInChallenge::Results::Create(
-      challenge, signed_nonce);
+      std::vector<char>(challenge.begin(), challenge.end()),
+      std::vector<char>(signed_nonce.begin(), signed_nonce.end()));
   SendResponse(true);
 }
 
 EasyUnlockPrivateTrySignInSecretFunction::
     EasyUnlockPrivateTrySignInSecretFunction() {
 }
 
 EasyUnlockPrivateTrySignInSecretFunction::
     ~EasyUnlockPrivateTrySignInSecretFunction() {
 }
 
 bool EasyUnlockPrivateTrySignInSecretFunction::RunSync() {
   scoped_ptr<easy_unlock_private::TrySignInSecret::Params> params(
       easy_unlock_private::TrySignInSecret::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
 
   Profile* profile = Profile::FromBrowserContext(browser_context());
-  EasyUnlockService::Get(profile)->FinalizeSignin(params->sign_in_secret);
+  EasyUnlockService::Get(profile)->FinalizeSignin(std::string(
+      params->sign_in_secret.begin(), params->sign_in_secret.end()));
   return true;
 }
 
 EasyUnlockPrivateGetUserInfoFunction::EasyUnlockPrivateGetUserInfoFunction() {
 }
 
 EasyUnlockPrivateGetUserInfoFunction::~EasyUnlockPrivateGetUserInfoFunction() {
 }
 
 bool EasyUnlockPrivateGetUserInfoFunction::RunSync() {
@@ skipping 25 matching lines @@
 #if defined(OS_CHROMEOS)
   EasyUnlockService* service =
       EasyUnlockService::Get(Profile::FromBrowserContext(browser_context()));
   const std::vector<ui::ScaleFactor>& supported_scale_factors =
       ui::GetSupportedScaleFactors();
 
   base::RefCountedMemory* user_image =
       chromeos::options::UserImageSource::GetUserImage(
           service->GetUserEmail(), supported_scale_factors.back());
 
-  results_ = easy_unlock_private::GetUserImage::Results::Create(std::string(
-      reinterpret_cast<const char*>(user_image->front()), user_image->size()));
+  results_ =
+      easy_unlock_private::GetUserImage::Results::Create(std::vector<char>(
+          user_image->front(), user_image->front() + user_image->size()));
 #else
   // TODO(tengs): Find a way to get the profile picture for non-ChromeOS
   // devices.
   results_ = easy_unlock_private::GetUserImage::Results::Create("");
   SetError("Not supported on non-ChromeOS platforms.");
 #endif
   return true;
 }
 
 EasyUnlockPrivateGetConnectionInfoFunction::
@@ skipping 34 matching lines @@
   scoped_ptr<base::ListValue> results(new base::ListValue());
   results->AppendInteger(connection_info.rssi);
   results->AppendInteger(connection_info.transmit_power);
   results->AppendInteger(connection_info.max_transmit_power);
   SetResultList(results.Pass());
   SendResponse(true);
 }
 
 }  // namespace api
 }  // namespace extensions