Update EME errors to use TypeError

third_party/WebKit/Source/modules/encryptedmedia/ContentDecryptionModuleResultPromise.cpp

 // 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 "modules/encryptedmedia/ContentDecryptionModuleResultPromise.h"
 
 #include "bindings/core/v8/ScriptPromise.h"
 #include "bindings/core/v8/ScriptState.h"
+#include "bindings/core/v8/V8ThrowException.h"
 #include "core/dom/DOMException.h"
 #include "core/dom/ExecutionContext.h"
 #include "core/dom/ExecutionContextTask.h"
 #include "public/platform/WebString.h"
 #include "wtf/Assertions.h"
 
 namespace blink {
 
 ExceptionCode WebCdmExceptionToExceptionCode(WebContentDecryptionModuleException cdmException)
 {
     switch (cdmException) {
+    case WebContentDecryptionModuleExceptionTypeError:
+        return V8TypeError;
     case WebContentDecryptionModuleExceptionNotSupportedError:
         return NotSupportedError;
     case WebContentDecryptionModuleExceptionInvalidStateError:
         return InvalidStateError;
-    case WebContentDecryptionModuleExceptionInvalidAccessError:
-        return InvalidAccessError;
     case WebContentDecryptionModuleExceptionQuotaExceededError:
         return QuotaExceededError;
     case WebContentDecryptionModuleExceptionUnknownError:
         return UnknownError;
-    case WebContentDecryptionModuleExceptionClientError:
-    case WebContentDecryptionModuleExceptionOutputError:
-        // Currently no matching DOMException for these 2 errors.
-        // FIXME: Update DOMException to handle these if actually added to
-        // the EME spec.
-        return UnknownError;
     }
 
     NOTREACHED();
     return UnknownError;
 }
 
 ContentDecryptionModuleResultPromise::ContentDecryptionModuleResultPromise(ScriptState* scriptState)
     : m_resolver(ScriptPromiseResolver::create(scriptState))
 {
 }
@@ skipping 44 matching lines @@
 
 void ContentDecryptionModuleResultPromise::reject(ExceptionCode code, const String& errorMessage)
 {
     // Reject the promise asynchronously. This avoids problems when gc is
     // destroying objects that result in unfulfilled promises being rejected.
     // (Resolving promises is still done synchronously as there may be events
     // already posted that need to happen only after the promise is resolved.)
     // TODO(jrummell): Make resolving a promise asynchronous as well (including
     // making sure events still happen after the promise is resolved).
     if (getExecutionContext()) {
         getExecutionContext()->postTask(BLINK_FROM_HERE, createSameThreadTask(&ContentDecryptionModuleResultPromise::rejectInternal, wrapPersistent(this), code, errorMessage));

[haraken, 2016/09/20 05:22:32]

I begin to think that this postTask is the culprit of the weirdness...

- It looks strange that you need to enter a ScriptState::Scope before you create
a JS error. You should already be in a correct ScriptState when you create a JS
error.

- As we discussed before (e.g., https://codereview.chromium.org/1987883002), it
is wrong to use postTask to work around the gc-related crash. You should
guarantee that the promise is explicitly rejected without relying on GC timings.

- If you fix that behavior, you can remove postTask from here. Then you
shouldn't need to enter ScriptState::Scope here because you're already in a
correct ScriptState.

What do you think?

     }
 }
 
 void ContentDecryptionModuleResultPromise::rejectInternal(ExceptionCode code, const String& errorMessage)
 {
-    m_resolver->reject(DOMException::create(code, errorMessage));
+    // Reject promise with an appropriate error. Since |code| may represent
+    // a TypeError, use V8ThrowException::createDOMException() to handle it.
+    if (m_resolver->getScriptState()->contextIsValid()) {
+        ScriptState::Scope scope(m_resolver->getScriptState());
+        v8::Isolate* isolate = m_resolver->getScriptState()->isolate();
+        m_resolver->reject(V8ThrowException::createDOMException(isolate, code, errorMessage));
+    }
+
     m_resolver.clear();
 }
 
 ExecutionContext* ContentDecryptionModuleResultPromise::getExecutionContext() const
 {
     return m_resolver->getExecutionContext();
 }
 
 DEFINE_TRACE(ContentDecryptionModuleResultPromise)
 {
     visitor->trace(m_resolver);
     ContentDecryptionModuleResult::trace(visitor);
 }
 
 } // namespace blink