Oilpan: Remove most WillBe types from the code base

third_party/WebKit/Source/modules/encryptedmedia/HTMLMediaElementEncryptedMedia.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/HTMLMediaElementEncryptedMedia.h"
 
 #include "bindings/core/v8/ExceptionState.h"
 #include "bindings/core/v8/ScriptPromise.h"
 #include "bindings/core/v8/ScriptPromiseResolver.h"
 #include "bindings/core/v8/ScriptState.h"
@@ skipping 51 matching lines @@
     void clearExistingMediaKeys();
     void setNewMediaKeys();
 
     void finish();
     void fail(ExceptionCode, const String& errorMessage);
 
     void clearFailed(ExceptionCode, const String& errorMessage);
     void setFailed(ExceptionCode, const String& errorMessage);
 
     // Keep media element alive until promise is fulfilled
-    RefPtrWillBeMember<HTMLMediaElement> m_element;
+    Member<HTMLMediaElement> m_element;
     Member<MediaKeys> m_newMediaKeys;
     bool m_madeReservation;
     Timer<SetMediaKeysHandler> m_timer;
 };
 
 typedef Function<void()> SuccessCallback;
 typedef Function<void(ExceptionCode, const String&)> FailureCallback;
 
 // Represents the result used when setContentDecryptionModule() is called.
 // Calls |success| if result is resolved, |failure| is result is rejected.
@@ skipping 223 matching lines @@
 #endif
 }
 
 const char* HTMLMediaElementEncryptedMedia::supplementName()
 {
     return "HTMLMediaElementEncryptedMedia";
 }
 
 HTMLMediaElementEncryptedMedia& HTMLMediaElementEncryptedMedia::from(HTMLMediaElement& element)
 {
-    HTMLMediaElementEncryptedMedia* supplement = static_cast<HTMLMediaElementEncryptedMedia*>(WillBeHeapSupplement<HTMLMediaElement>::from(element, supplementName()));
+    HTMLMediaElementEncryptedMedia* supplement = static_cast<HTMLMediaElementEncryptedMedia*>(HeapSupplement<HTMLMediaElement>::from(element, supplementName()));
     if (!supplement) {
         supplement = new HTMLMediaElementEncryptedMedia(element);
-        provideTo(element, supplementName(), adoptPtrWillBeNoop(supplement));
+        provideTo(element, supplementName(), (supplement));
     }
     return *supplement;
 }
 
 bool HTMLMediaElementEncryptedMedia::setEmeMode(EmeMode emeMode)
 {
     if (m_emeMode != EmeModeNotSelected && m_emeMode != emeMode)
         return false;
 
     m_emeMode = emeMode;
@@ skipping 17 matching lines @@
     // 1. If mediaKeys and the mediaKeys attribute are the same object, return
     //    a promise resolved with undefined.
     if (thisElement.m_mediaKeys == mediaKeys)
         return ScriptPromise::cast(scriptState, v8::Undefined(scriptState->isolate()));
 
     // 2. Let promise be a new promise. Remaining steps done in handler.
     return SetMediaKeysHandler::create(scriptState, element, mediaKeys);
 }
 
 // Create a MediaEncryptedEvent for WD EME.
-static PassRefPtrWillBeRawPtr<Event> createEncryptedEvent(WebEncryptedMediaInitDataType initDataType, const unsigned char* initData, unsigned initDataLength)
+static RawPtr<Event> createEncryptedEvent(WebEncryptedMediaInitDataType initDataType, const unsigned char* initData, unsigned initDataLength)
 {
     MediaEncryptedEventInit initializer;
     initializer.setInitDataType(EncryptedMediaUtils::convertFromInitDataType(initDataType));
     initializer.setInitData(DOMArrayBuffer::create(initData, initDataLength));
     initializer.setBubbles(false);
     initializer.setCancelable(false);
 
     return MediaEncryptedEvent::create(EventTypeNames::encrypted, initializer);
 }
 
 // Create a 'needkey' MediaKeyEvent for v0.1b EME.
-static PassRefPtrWillBeRawPtr<Event> createWebkitNeedKeyEvent(const unsigned char* initData, unsigned initDataLength)
+static RawPtr<Event> createWebkitNeedKeyEvent(const unsigned char* initData, unsigned initDataLength)
 {
     MediaKeyEventInit webkitInitializer;
     webkitInitializer.setInitData(DOMUint8Array::create(initData, initDataLength));
 
     return MediaKeyEvent::create(EventTypeNames::webkitneedkey, webkitInitializer);
 }
 
 void HTMLMediaElementEncryptedMedia::webkitGenerateKeyRequest(HTMLMediaElement& element, const String& keySystem, PassRefPtr<DOMUint8Array> initData, ExceptionState& exceptionState)
 {
     HTMLMediaElementEncryptedMedia::from(element).generateKeyRequest(element.webMediaPlayer(), keySystem, initData, exceptionState);
@@ skipping 113 matching lines @@
 }
 
 void HTMLMediaElementEncryptedMedia::keyAdded(const WebString& keySystem, const WebString& sessionId)
 {
     WTF_LOG(Media, "HTMLMediaElementEncryptedMedia::mediaPlayerKeyAdded");
 
     MediaKeyEventInit initializer;
     initializer.setKeySystem(keySystem);
     initializer.setSessionId(sessionId);
 
-    RefPtrWillBeRawPtr<Event> event = MediaKeyEvent::create(EventTypeNames::webkitkeyadded, initializer);
+    RawPtr<Event> event = MediaKeyEvent::create(EventTypeNames::webkitkeyadded, initializer);
     event->setTarget(m_mediaElement);
     m_mediaElement->scheduleEvent(event.release());
 }
 
 void HTMLMediaElementEncryptedMedia::keyError(const WebString& keySystem, const WebString& sessionId, WebMediaPlayerEncryptedMediaClient::MediaKeyErrorCode errorCode, unsigned short systemCode)
 {
     WTF_LOG(Media, "HTMLMediaElementEncryptedMedia::mediaPlayerKeyError: sessionID=%s, errorCode=%d, systemCode=%d", sessionId.utf8().data(), errorCode, systemCode);
 
     MediaKeyError::Code mediaKeyErrorCode = MediaKeyError::MEDIA_KEYERR_UNKNOWN;
     switch (errorCode) {
@@ skipping 16 matching lines @@
         mediaKeyErrorCode = MediaKeyError::MEDIA_KEYERR_DOMAIN;
         break;
     }
 
     MediaKeyEventInit initializer;
     initializer.setKeySystem(keySystem);
     initializer.setSessionId(sessionId);
     initializer.setErrorCode(MediaKeyError::create(mediaKeyErrorCode));
     initializer.setSystemCode(systemCode);
 
-    RefPtrWillBeRawPtr<Event> event = MediaKeyEvent::create(EventTypeNames::webkitkeyerror, initializer);
+    RawPtr<Event> event = MediaKeyEvent::create(EventTypeNames::webkitkeyerror, initializer);
     event->setTarget(m_mediaElement);
     m_mediaElement->scheduleEvent(event.release());
 }
 
 void HTMLMediaElementEncryptedMedia::keyMessage(const WebString& keySystem, const WebString& sessionId, const unsigned char* message, unsigned messageLength, const WebURL& defaultURL)
 {
     WTF_LOG(Media, "HTMLMediaElementEncryptedMedia::mediaPlayerKeyMessage: sessionID=%s", sessionId.utf8().data());
 
     MediaKeyEventInit initializer;
     initializer.setKeySystem(keySystem);
     initializer.setSessionId(sessionId);
     initializer.setMessage(DOMUint8Array::create(message, messageLength));
     initializer.setDefaultURL(KURL(defaultURL));
 
-    RefPtrWillBeRawPtr<Event> event = MediaKeyEvent::create(EventTypeNames::webkitkeymessage, initializer);
+    RawPtr<Event> event = MediaKeyEvent::create(EventTypeNames::webkitkeymessage, initializer);
     event->setTarget(m_mediaElement);
     m_mediaElement->scheduleEvent(event.release());
 }
 
 void HTMLMediaElementEncryptedMedia::encrypted(WebEncryptedMediaInitDataType initDataType, const unsigned char* initData, unsigned initDataLength)
 {
     WTF_LOG(Media, "HTMLMediaElementEncryptedMedia::encrypted");
 
     if (RuntimeEnabledFeatures::encryptedMediaEnabled()) {
         // Send event for WD EME.
-        RefPtrWillBeRawPtr<Event> event;
+        RawPtr<Event> event;
         if (m_mediaElement->isMediaDataCORSSameOrigin(m_mediaElement->executionContext()->securityOrigin())) {
             event = createEncryptedEvent(initDataType, initData, initDataLength);
         } else {
             // Current page is not allowed to see content from the media file,
             // so don't return the initData. However, they still get an event.
             event = createEncryptedEvent(WebEncryptedMediaInitDataType::Unknown, nullptr, 0);
         }
 
         event->setTarget(m_mediaElement);
         m_mediaElement->scheduleEvent(event.release());
     }
 
     if (RuntimeEnabledFeatures::prefixedEncryptedMediaEnabled()) {
         // Send event for v0.1b EME.
-        RefPtrWillBeRawPtr<Event> event = createWebkitNeedKeyEvent(initData, initDataLength);
+        RawPtr<Event> event = createWebkitNeedKeyEvent(initData, initDataLength);
         event->setTarget(m_mediaElement);
         m_mediaElement->scheduleEvent(event.release());
     }
 }
 
 void HTMLMediaElementEncryptedMedia::didBlockPlaybackWaitingForKey()
 {
     WTF_LOG(Media, "HTMLMediaElementEncryptedMedia::didBlockPlaybackWaitingForKey");
 
     // From https://w3c.github.io/encrypted-media/#queue-waitingforkey:
     // It should only be called when the HTMLMediaElement object is potentially
     // playing and its readyState is equal to HAVE_FUTURE_DATA or greater.
     // FIXME: Is this really required?
 
     // 1. Let the media element be the specified HTMLMediaElement object.
     // 2. If the media element's waiting for key value is false, queue a task
     //    to fire a simple event named waitingforkey at the media element.
     if (!m_isWaitingForKey) {
-        RefPtrWillBeRawPtr<Event> event = Event::create(EventTypeNames::waitingforkey);
+        RawPtr<Event> event = Event::create(EventTypeNames::waitingforkey);
         event->setTarget(m_mediaElement);
         m_mediaElement->scheduleEvent(event.release());
     }
 
     // 3. Set the media element's waiting for key value to true.
     m_isWaitingForKey = true;
 
     // 4. Suspend playback.
     //    (Already done on the Chromium side by the decryptors.)
 }
@@ skipping 10 matching lines @@
 
 WebContentDecryptionModule* HTMLMediaElementEncryptedMedia::contentDecryptionModule()
 {
     return m_mediaKeys ? m_mediaKeys->contentDecryptionModule() : 0;
 }
 
 DEFINE_TRACE(HTMLMediaElementEncryptedMedia)
 {
     visitor->trace(m_mediaElement);
     visitor->trace(m_mediaKeys);
-    WillBeHeapSupplement<HTMLMediaElement>::trace(visitor);
+    HeapSupplement<HTMLMediaElement>::trace(visitor);
 }
 
 } // namespace blink