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

chrome/browser/extensions/api/enterprise_platform_keys/enterprise_platform_keys_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/enterprise_platform_keys/enterprise_platform_keys_api.h"
 
 #include "base/bind.h"
+#include "base/stl_util.h"
 #include "base/values.h"
 #include "chrome/browser/chromeos/platform_keys/platform_keys.h"
 #include "chrome/browser/chromeos/platform_keys/platform_keys_service.h"
 #include "chrome/browser/chromeos/platform_keys/platform_keys_service_factory.h"
 #include "chrome/common/extensions/api/enterprise_platform_keys.h"
 #include "chrome/common/extensions/api/enterprise_platform_keys_internal.h"
 #include "content/public/browser/browser_thread.h"
 #include "net/cert/x509_certificate.h"
 
 namespace extensions {
@@ skipping 68 matching lines @@
           &EnterprisePlatformKeysInternalGenerateKeyFunction::OnGeneratedKey,
           this));
   return RespondLater();
 }
 
 void EnterprisePlatformKeysInternalGenerateKeyFunction::OnGeneratedKey(
     const std::string& public_key_der,
     const std::string& error_message) {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
   if (error_message.empty()) {
-    Respond(
-        ArgumentList(api_epki::GenerateKey::Results::Create(public_key_der)));
+    Respond(ArgumentList(api_epki::GenerateKey::Results::Create(
+        std::vector<char>(public_key_der.begin(), public_key_der.end()))));
   } else {
     Respond(Error(error_message));
   }
 }
 
 EnterprisePlatformKeysInternalSignFunction::
     ~EnterprisePlatformKeysInternalSignFunction() {
 }
 
 ExtensionFunction::ResponseAction
@@ skipping 17 matching lines @@
   else
     return RespondNow(Error(kErrorAlgorithmNotSupported));
 
   chromeos::PlatformKeysService* service =
       chromeos::PlatformKeysServiceFactory::GetForBrowserContext(
           browser_context());
   DCHECK(service);
 
   service->Sign(
       platform_keys_token_id,
-      params->public_key,
-      hash_algorithm,
-      params->data,
+      std::string(params->public_key.begin(), params->public_key.end()),
+      hash_algorithm, std::string(params->data.begin(), params->data.end()),
       extension_id(),
       base::Bind(&EnterprisePlatformKeysInternalSignFunction::OnSigned, this));
   return RespondLater();
 }
 
 void EnterprisePlatformKeysInternalSignFunction::OnSigned(
     const std::string& signature,
     const std::string& error_message) {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
-  if (error_message.empty())
-    Respond(ArgumentList(api_epki::Sign::Results::Create(signature)));
-  else
+  if (error_message.empty()) {
+    Respond(ArgumentList(api_epki::Sign::Results::Create(
+        std::vector<char>(signature.begin(), signature.end()))));
+  } else {
     Respond(Error(error_message));
+  }
 }
 
 EnterprisePlatformKeysGetCertificatesFunction::
     ~EnterprisePlatformKeysGetCertificatesFunction() {
 }
 
 ExtensionFunction::ResponseAction
 EnterprisePlatformKeysGetCertificatesFunction::Run() {
   scoped_ptr<api_epk::GetCertificates::Params> params(
       api_epk::GetCertificates::Params::Create(*args_));
@@ skipping 41 matching lines @@
 
 ExtensionFunction::ResponseAction
 EnterprisePlatformKeysImportCertificateFunction::Run() {
   scoped_ptr<api_epk::ImportCertificate::Params> params(
       api_epk::ImportCertificate::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params);
   std::string platform_keys_token_id;
   if (!ValidateToken(params->token_id, &platform_keys_token_id))
     return RespondNow(Error(kErrorInvalidToken));
 
-  const std::string& cert_der = params->certificate;
+  const std::vector<char>& cert_der = params->certificate;
   scoped_refptr<net::X509Certificate> cert_x509 =
-      net::X509Certificate::CreateFromBytes(cert_der.data(), cert_der.size());
+      net::X509Certificate::CreateFromBytes(vector_as_array(&cert_der),
+                                            cert_der.size());
   if (!cert_x509.get())
     return RespondNow(Error(kErrorInvalidX509Cert));
 
   chromeos::platform_keys::ImportCertificate(
       platform_keys_token_id,
       cert_x509,
       base::Bind(&EnterprisePlatformKeysImportCertificateFunction::
                      OnImportedCertificate,
                  this),
       browser_context());
@@ skipping 15 matching lines @@
 
 ExtensionFunction::ResponseAction
 EnterprisePlatformKeysRemoveCertificateFunction::Run() {
   scoped_ptr<api_epk::RemoveCertificate::Params> params(
       api_epk::RemoveCertificate::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params);
   std::string platform_keys_token_id;
   if (!ValidateToken(params->token_id, &platform_keys_token_id))
     return RespondNow(Error(kErrorInvalidToken));
 
-  const std::string& cert_der = params->certificate;
+  const std::vector<char>& cert_der = params->certificate;
   scoped_refptr<net::X509Certificate> cert_x509 =
-      net::X509Certificate::CreateFromBytes(cert_der.data(), cert_der.size());
+      net::X509Certificate::CreateFromBytes(vector_as_array(&cert_der),
+                                            cert_der.size());
   if (!cert_x509.get())
     return RespondNow(Error(kErrorInvalidX509Cert));
 
   chromeos::platform_keys::RemoveCertificate(
       platform_keys_token_id,
       cert_x509,
       base::Bind(&EnterprisePlatformKeysRemoveCertificateFunction::
                      OnRemovedCertificate,
                  this),
       browser_context());
@@ skipping 43 matching lines @@
       Respond(Error(kErrorInternal));
       return;
     }
     token_ids.push_back(token_id);
   }
 
   Respond(ArgumentList(api_epki::GetTokens::Results::Create(token_ids)));
 }
 
 }  // namespace extensions