WebCrypto: Add SHA-1 support to crypto.subtle.digest().

Source/modules/crypto/CryptoOperation.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 13 matching lines @@
  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  * 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/CryptoOperation.h"
 
+#include "bindings/v8/custom/V8ArrayBufferCustom.h" // MUST precede ScriptPromiseResolver for compilation to work.
+#include "bindings/v8/ScriptPromiseResolver.h"
 #include "modules/crypto/Algorithm.h"
+#include "public/platform/WebCrypto.h"
+#include "public/web/WebArrayBuffer.h"

[abarth-chromium, 2013/07/12 16:58:31]

This is a backwards dependency.  You can fix this by moving
public/web/WebArrayBuffer.h to public/platform/WebArrayBuffer.h and
Source/web/WebArrayBuffer.cpp to
Source/core/platform/chromium/support/WebArrayBuffer.cpp.

[eroman, 2013/07/12 20:38:19]

Done. I also added a temporary forwarding header from web/WebArrayBuffer.h -->
platform/WebArrayBuffer.h, since there is code that depends on this in chromium.

+#include "wtf/ArrayBuffer.h"
+#include "wtf/ArrayBufferView.h"
 
 namespace WebCore {
 
-CryptoOperation::CryptoOperation(const WebKit::WebCryptoAlgorithm& algorithm)
+class CryptoOperation::Result : public WebKit::WebCryptoOperationResult {
+public:
+    explicit Result(CryptoOperation* parent) : m_parent(parent) { }
+
+    virtual void setArrayBuffer(const WebKit::WebArrayBuffer& buffer) OVERRIDE
+    {
+        ASSERT(m_parent->m_state == Finishing);
+        m_parent->m_state = Done;
+        m_parent->m_impl = 0;
+
+        m_parent->m_promiseResolver->fulfill(PassRefPtr<ArrayBuffer>(buffer));
+    }

[abarth-chromium, 2013/07/12 16:58:31]

Should this clear m_result when done too?

[eroman, 2013/07/12 20:38:19]

I would prefer not to clear m_result, for debugging purposes.

<optional_justification>
One bug which an embedder might do is to set the result more than once (right
now there is just one result type, ArrayBuffer; however in the future there will
be more type-specific methods).

I would like to ASSERT that one and only one method is called. If I delete
m_result right here then such errors will be use-after-frees, rather than
hitting my ASSERT() on m_state.

Perhaps this is weak reasoning, and certainly tools like valgrind should catch
such mis-uses. So I am happy to change the code.
</optional_justification>

+
+private:
+    CryptoOperation* m_parent;
+};
+
+CryptoOperation::~CryptoOperation()
+{
+    abort();
+    ASSERT(!m_impl);
+}
+
+PassRefPtr<CryptoOperation> CryptoOperation::create(const WebKit::WebCryptoAlgorithm& algorithm, WebKit::WebCryptoOperation* impl)
+{
+    return adoptRef(new CryptoOperation(algorithm, impl));
+}
+
+CryptoOperation::CryptoOperation(const WebKit::WebCryptoAlgorithm& algorithm, WebKit::WebCryptoOperation* impl)
     : m_algorithm(algorithm)
+    , m_impl(impl)
+    , m_state(Processing)
+    , m_result(adoptPtr(new Result(this)))
 {
+    ASSERT(impl);
     ScriptWrappable::init(this);
+
+    m_promiseResolver = ScriptPromiseResolver::create();
+}
+
+CryptoOperation* CryptoOperation::process(ArrayBuffer* data)
+{
+    process(static_cast<unsigned char*>(data->data()), data->byteLength());
+    return this;
+}
+
+CryptoOperation* CryptoOperation::process(ArrayBufferView* data)
+{
+    process(static_cast<unsigned char*>(data->baseAddress()), data->byteLength());
+    return this;
+}
+
+CryptoOperation* CryptoOperation::finish()
+{
+    switch (m_state) {
+    case Processing:
+        m_state = Finishing;
+        // NOTE: The following line can result in re-entrancy to |this|
+        m_impl->finish(m_result.get());
+        break;
+    case Finishing:
+        // Calling finish() twice is a no-op.
+        break;
+    case Done:
+        // Calling finish() after already complete is a no-op.
+        ASSERT(!m_impl);
+        break;
+    }
+
+    return this;
+}
+
+CryptoOperation* CryptoOperation::abort()
+{
+    switch (m_state) {
+    case Processing:
+    case Finishing:
+        // This will cause m_impl to be deleted.
+        m_impl->abort();
+        m_state = Done;
+        m_impl = 0;
+        m_promiseResolver->reject(ScriptValue(v8::Null()));

[abarth-chromium, 2013/07/12 16:58:31]

We should give ScriptValue a factor method for making null so you don't need to
use the V8 API directly (e.g., ScriptValue::createNull()   ).

[eroman, 2013/07/12 20:38:19]

Done.

+        break;
+    case Done:
+        ASSERT(!m_impl);
+        break;
+    }
+
+    return this;
 }
 
 Algorithm* CryptoOperation::algorithm()
 {
     if (!m_algorithmNode)
         m_algorithmNode = Algorithm::create(m_algorithm);
     return m_algorithmNode.get();
 }
 
+ScriptObject CryptoOperation::promise()
+{
+    return m_promiseResolver->promise();
+}
+
+void CryptoOperation::process(const unsigned char* bytes, size_t size)
+{
+    switch (m_state) {
+    case Processing:
+        m_impl->process(bytes, size);
+        break;
+    case Finishing:
+    case Done:
+        return;
+    }
+}
+
 } // namespace WebCore