EME: Improve promise lifetime

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

 /*
  * Copyright (C) 2013 Apple 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:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
@@ skipping 13 matching lines @@
  */
 
 #include "modules/encryptedmedia/MediaKeys.h"
 
 #include "bindings/core/v8/ScriptState.h"
 #include "core/dom/DOMArrayBuffer.h"
 #include "core/dom/DOMException.h"
 #include "core/dom/ExceptionCode.h"
 #include "core/dom/ExecutionContext.h"
 #include "core/html/HTMLMediaElement.h"
+#include "modules/encryptedmedia/ContentDecryptionModuleResultPromise.h"
 #include "modules/encryptedmedia/EncryptedMediaUtils.h"
 #include "modules/encryptedmedia/MediaKeySession.h"
-#include "modules/encryptedmedia/SimpleContentDecryptionModuleResultPromise.h"
 #include "platform/Timer.h"
 #include "public/platform/WebContentDecryptionModule.h"
 #include "wtf/RefPtr.h"
 #include <memory>
 
 #define MEDIA_KEYS_LOG_LEVEL 3
 
 namespace blink {
 
 // A class holding a pending action.
@@ skipping 28 matching lines @@
 };
 
 // This class wraps the promise resolver used when setting the certificate
 // and is passed to Chromium to fullfill the promise. This implementation of
 // complete() will resolve the promise with true, while completeWithError()
 // will reject the promise with an exception. completeWithSession()
 // is not expected to be called, and will reject the promise.
 class SetCertificateResultPromise
     : public ContentDecryptionModuleResultPromise {
  public:
-  SetCertificateResultPromise(ScriptState* scriptState)
-      : ContentDecryptionModuleResultPromise(scriptState) {}
+  SetCertificateResultPromise(ScriptState* scriptState, MediaKeys* mediaKeys)
+      : ContentDecryptionModuleResultPromise(scriptState),
+        m_mediaKeys(mediaKeys) {}
 
   ~SetCertificateResultPromise() override {}
 
   // ContentDecryptionModuleResult implementation.
-  void complete() override { resolve(true); }
+  void complete() override {
+    if (!isValidToFulfillPromise())
+      return;
+
+    resolve(true);
+  }
 
   void completeWithError(WebContentDecryptionModuleException exceptionCode,
                          unsigned long systemCode,
                          const WebString& errorMessage) override {
+    if (!isValidToFulfillPromise())
+      return;
+
     // The EME spec specifies that "If the Key System implementation does
     // not support server certificates, return a promise resolved with
     // false." So convert any NOTSUPPORTEDERROR into resolving with false.
     if (exceptionCode == WebContentDecryptionModuleExceptionNotSupportedError) {
       resolve(false);
       return;
     }
 
     ContentDecryptionModuleResultPromise::completeWithError(
         exceptionCode, systemCode, errorMessage);
   }
+
+  DEFINE_INLINE_TRACE() {
+    visitor->trace(m_mediaKeys);
+    ContentDecryptionModuleResultPromise::trace(visitor);
+  }
+
+ private:
+  Member<MediaKeys> m_mediaKeys;
 };
 
 MediaKeys* MediaKeys::create(
     ExecutionContext* context,
     const WebVector<WebEncryptedMediaSessionType>& supportedSessionTypes,
     std::unique_ptr<WebContentDecryptionModule> cdm) {
   MediaKeys* mediaKeys =
       new MediaKeys(context, supportedSessionTypes, std::move(cdm));
   mediaKeys->suspendIfNeeded();
   return mediaKeys;
@@ skipping 70 matching lines @@
   //    "NotSupportedError".
   //    (Let the CDM decide whether to support this or not.)
 
   // 3. Let certificate be a copy of the contents of the serverCertificate
   //    parameter.
   DOMArrayBuffer* serverCertificateBuffer = DOMArrayBuffer::create(
       serverCertificate.data(), serverCertificate.byteLength());
 
   // 4. Let promise be a new promise.
   SetCertificateResultPromise* result =
-      new SetCertificateResultPromise(scriptState);
+      new SetCertificateResultPromise(scriptState, this);
   ScriptPromise promise = result->promise();
 
   // 5. Run the following steps asynchronously (documented in timerFired()).
   m_pendingActions.append(PendingAction::CreatePendingSetServerCertificate(
       result, serverCertificateBuffer));
   if (!m_timer.isActive())
     m_timer.startOneShot(0, BLINK_FROM_HERE);
 
   // 6. Return promise.
   return promise;
@@ skipping 82 matching lines @@
   // Remain around if there are pending events.
   DVLOG(MEDIA_KEYS_LOG_LEVEL)
       << __func__ << "(" << this << ")"
       << (!m_pendingActions.isEmpty() ? " !m_pendingActions.isEmpty()" : "")
       << (m_reservedForMediaElement ? " m_reservedForMediaElement" : "");
 
   return !m_pendingActions.isEmpty() || m_reservedForMediaElement;
 }
 
 }  // namespace blink