[webcrypto] Make operations run on worker threads.

content/child/webcrypto/jwk.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 "jwk.h"
+
 #include <algorithm>
 #include <functional>
 #include <map>
+
 #include "base/json/json_reader.h"
 #include "base/json/json_writer.h"
 #include "base/lazy_instance.h"
+#include "base/strings/string_piece.h"
 #include "base/strings/stringprintf.h"
 #include "content/child/webcrypto/crypto_data.h"
 #include "content/child/webcrypto/platform_crypto.h"
 #include "content/child/webcrypto/shared_crypto.h"
 #include "content/child/webcrypto/status.h"
 #include "content/child/webcrypto/webcrypto_util.h"
 #include "third_party/WebKit/public/platform/WebCryptoKeyAlgorithm.h"
 
 namespace content {
 
@@ skipping 271 matching lines @@
   return Status::Success();
 }
 
 // Returns true if the set bits in b make up a subset of the set bits in a.
 bool ContainsKeyUsages(blink::WebCryptoKeyUsageMask a,
                        blink::WebCryptoKeyUsageMask b) {
   return (a & b) == b;
 }
 
 // Writes a secret/symmetric key to a JWK dictionary.
-void WriteSecretKey(const blink::WebArrayBuffer& raw_key,
+void WriteSecretKey(const std::vector<uint8>& raw_key,
                     base::DictionaryValue* jwk_dict) {
   DCHECK(jwk_dict);
   jwk_dict->SetString("kty", "oct");
   // For a secret/symmetric key, the only extra JWK field is 'k', containing the
   // base64url encoding of the raw key.
-  DCHECK(!raw_key.isNull());
-  DCHECK(raw_key.data());
-  DCHECK(raw_key.byteLength());
-  unsigned int key_length_bytes = raw_key.byteLength();
-  const base::StringPiece key_str(static_cast<const char*>(raw_key.data()),
-                                  key_length_bytes);
+  const base::StringPiece key_str(
+      reinterpret_cast<const char*>(Uint8VectorStart(raw_key)), raw_key.size());
   jwk_dict->SetString("k", Base64EncodeUrlSafe(key_str));
 }
 
 // Writes an RSA public key to a JWK dictionary
 void WriteRsaPublicKey(const std::vector<uint8>& modulus,
                        const std::vector<uint8>& public_exponent,
                        base::DictionaryValue* jwk_dict) {
   DCHECK(jwk_dict);
   DCHECK(modulus.size());
   DCHECK(public_exponent.size());
@@ skipping 460 matching lines @@
                                         CryptoData(jwk_n_value),
                                         CryptoData(jwk_e_value),
                                         key);
 
   }
 
   return Status::ErrorJwkUnrecognizedKty();
 }
 
 Status ExportKeyJwk(const blink::WebCryptoKey& key,
-                    blink::WebArrayBuffer* buffer) {
+                    std::vector<uint8>* buffer) {
   DCHECK(key.extractable());
   base::DictionaryValue jwk_dict;
   Status status = Status::OperationError();
 
   switch (key.type()) {
     case blink::WebCryptoKeyTypeSecret: {
-      blink::WebArrayBuffer exported_key;
+      std::vector<uint8> exported_key;
       status = ExportKey(blink::WebCryptoKeyFormatRaw, key, &exported_key);
       if (status.IsError())
         return status;
       WriteSecretKey(exported_key, &jwk_dict);
       break;
     }
     case blink::WebCryptoKeyTypePublic: {
       // Currently only RSA public key export is supported.
       if (!IsRsaPublicKey(key))
         return Status::ErrorUnsupported();
@@ skipping 16 matching lines @@
   }
 
   WriteKeyOps(key.usages(), &jwk_dict);
   WriteExt(key.extractable(), &jwk_dict);
   status = WriteAlg(key.algorithm(), &jwk_dict);
   if (status.IsError())
     return status;
 
   std::string json;
   base::JSONWriter::Write(&jwk_dict, &json);
-  *buffer = CreateArrayBuffer(reinterpret_cast<const uint8*>(json.data()),
-                              json.size());
+  buffer->assign(json.data(), json.data() + json.size());
   return Status::Success();
 }
 
 }  // namespace webcrypto
 
 }  // namespace content