Add V8ObjectBuilder helper and use in modules/crypto/

Source/modules/crypto/CryptoKey.cpp

 /*
  * Copyright (C) 2013 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 14 matching lines @@
  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #include "config.h"
 #include "modules/crypto/CryptoKey.h"
 
 #include "bindings/core/v8/ExceptionState.h"
+#include "bindings/core/v8/V8ObjectBuilder.h"
 #include "bindings/core/v8/V8Uint8Array.h"
 #include "core/dom/ExceptionCode.h"
 #include "platform/CryptoResult.h"
 #include "public/platform/WebCryptoAlgorithmParams.h"
 #include "public/platform/WebCryptoKeyAlgorithm.h"
 #include "public/platform/WebString.h"
 
 namespace blink {
 
 namespace {
@@ skipping 48 matching lines @@
     for (size_t i = 0; i < WTF_ARRAY_LENGTH(keyUsageMappings); ++i) {
         if (keyUsageMappings[i].name == usageString)
             return keyUsageMappings[i].value;
     }
     return 0;
 }
 
 class DictionaryBuilder : public blink::WebCryptoKeyAlgorithmDictionary {
 public:
     explicit DictionaryBuilder(ScriptState* scriptState)
-        : m_scriptState(scriptState)
-        , m_dictionary(Dictionary::createEmpty(scriptState->isolate()))
+        : m_builder(scriptState)
     {
     }
 
     virtual void setString(const char* propertyName, const char* value)
     {
-        m_dictionary.set(propertyName, value);
+        m_builder.addString(propertyName, value);
     }
 
     virtual void setUint(const char* propertyName, unsigned value)
     {
-        m_dictionary.set(propertyName, value);
+        m_builder.addNumber(propertyName, value);
     }
 
     virtual void setAlgorithm(const char* propertyName, const blink::WebCryptoAlgorithm& algorithm)
     {
         ASSERT(algorithm.paramsType() == blink::WebCryptoAlgorithmParamsTypeNone);
 
-        Dictionary algorithmValue = Dictionary::createEmpty(m_scriptState->isolate());
-        algorithmValue.set("name", blink::WebCryptoAlgorithm::lookupAlgorithmInfo(algorithm.id())->name);
-        m_dictionary.set(propertyName, algorithmValue);
+        V8ObjectBuilder algorithmValue(m_builder.scriptState());
+        algorithmValue.addString("name", blink::WebCryptoAlgorithm::lookupAlgorithmInfo(algorithm.id())->name);
+        m_builder.add(propertyName, algorithmValue);
     }
 
     virtual void setUint8Array(const char* propertyName, const blink::WebVector<unsigned char>& vector)
     {
-        m_dictionary.set(propertyName, toV8(DOMUint8Array::create(vector.data(), vector.size()), m_scriptState->context()->Global(), m_scriptState->isolate()));
+        m_builder.add(propertyName, ScriptValue::from(m_builder.scriptState(), DOMUint8Array::create(vector.data(), vector.size())));

[bashi, 2015/03/25 01:09:25]

IMHO, having addUint8Array() in V8ObjectBuilder would make sense. WDYT?

[Jens Widell, 2015/03/25 11:16:04]

I'm not sure. Supporting generic values (e.g. ScriptValue) covers this (and many
other potential use-cases), and seems less arbitrary than explicitly supporting
the one "complex" type we currently need.

We could add

  template <typename T>
  V8ObjectBuilder add(String name, const T& value)
  {
    add(name, toV8(value, ...);
  }

of course.

[Jens Widell, 2015/03/25 11:34:01]

Generic add() added now, and the explicit ScriptValue variant dropped (since the
generic version handles ScriptValue).

     }
 
-    const Dictionary& dictionary() const { return m_dictionary; }
+    ScriptValue value() const { return m_builder.scriptValue(); }
 
 private:
-    RefPtr<ScriptState> m_scriptState;
-    Dictionary m_dictionary;
+    V8ObjectBuilder m_builder;
 };
 
 } // namespace
 
 CryptoKey::~CryptoKey()
 {
 }
 
 CryptoKey::CryptoKey(const WebCryptoKey& key)
     : m_key(key)
 {
 }
 
 String CryptoKey::type() const
 {
     return keyTypeToString(m_key.type());
 }
 
 bool CryptoKey::extractable() const
 {
     return m_key.extractable();
 }
 
 ScriptValue CryptoKey::algorithm(ScriptState* scriptState)
 {
     DictionaryBuilder builder(scriptState);
     m_key.algorithm().writeToDictionary(&builder);
-    return ScriptValue(scriptState, builder.dictionary().v8Value());
+    return builder.value();
 }
 
 // FIXME: This creates a new javascript array each time. What should happen
 //        instead is return the same (immutable) array. (Javascript callers can
 //        distinguish this by doing an == test on the arrays and seeing they are
 //        different).
 Vector<String> CryptoKey::usages() const
 {
     Vector<String> result;
     for (size_t i = 0; i < WTF_ARRAY_LENGTH(keyUsageMappings); ++i) {
@@ skipping 51 matching lines @@
         if (!usage) {
             result->completeWithError(WebCryptoErrorTypeType, "Invalid keyUsages argument");
             return false;
         }
         mask |= usage;
     }
     return true;
 }
 
 } // namespace blink