Cleanup blink:: prefix usage in Source/core/modules/[battery/*.cpp to indexeddb/*.cpp]

Source/modules/encryptedmedia/MediaKeySession.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 118 matching lines @@
 };
 
 // This class allows a MediaKeySession object to be created asynchronously.
 class MediaKeySessionInitializer : public ScriptPromiseResolver {
     WTF_MAKE_NONCOPYABLE(MediaKeySessionInitializer);
 
 public:
     static ScriptPromise create(ScriptState*, MediaKeys*, const String& initDataType, PassRefPtr<ArrayBuffer> initData, const String& sessionType);
     virtual ~MediaKeySessionInitializer();
 
-    void completeWithSession(blink::WebContentDecryptionModuleResult::SessionStatus);
+    void completeWithSession(WebContentDecryptionModuleResult::SessionStatus);
     void completeWithDOMException(ExceptionCode, const String& errorMessage);
 
 private:
     MediaKeySessionInitializer(ScriptState*, MediaKeys*, const String& initDataType, PassRefPtr<ArrayBuffer> initData, const String& sessionType);
     void timerFired(Timer<MediaKeySessionInitializer>*);
 
     Persistent<MediaKeys> m_mediaKeys;
-    OwnPtr<blink::WebContentDecryptionModuleSession> m_cdmSession;
+    OwnPtr<WebContentDecryptionModuleSession> m_cdmSession;
 
     // The next 3 values are simply the initialization data saved so that the
     // asynchronous creation has the data needed.
     String m_initDataType;
     RefPtr<ArrayBuffer> m_initData;
     String m_sessionType;
 
     Timer<MediaKeySessionInitializer> m_timer;
 };
 
 // Represents the result used when a new WebContentDecryptionModuleSession
 // object has been created. Needed as MediaKeySessionInitializer can't be both
 // a ScriptPromiseResolver and ContentDecryptionModuleResult at the same time.
 class NewMediaKeySessionResult FINAL : public ContentDecryptionModuleResult {
 public:
     NewMediaKeySessionResult(MediaKeySessionInitializer* initializer)
         : m_initializer(initializer)
     {
     }
 
     // ContentDecryptionModuleResult implementation.
     virtual void complete() OVERRIDE
     {
         ASSERT_NOT_REACHED();
         m_initializer->completeWithDOMException(InvalidStateError, "Unexpected completion.");
     }
 
-    virtual void completeWithSession(blink::WebContentDecryptionModuleResult::SessionStatus status) OVERRIDE
+    virtual void completeWithSession(WebContentDecryptionModuleResult::SessionStatus status) OVERRIDE
     {
         m_initializer->completeWithSession(status);
     }
 
-    virtual void completeWithError(blink::WebContentDecryptionModuleException code, unsigned long systemCode, const blink::WebString& message) OVERRIDE
+    virtual void completeWithError(WebContentDecryptionModuleException code, unsigned long systemCode, const WebString& message) OVERRIDE
     {
         m_initializer->completeWithDOMException(WebCdmExceptionToExceptionCode(code), message);
     }
 
 private:
     MediaKeySessionInitializer* m_initializer;
 };
 
 ScriptPromise MediaKeySessionInitializer::create(ScriptState* scriptState, MediaKeys* mediaKeys, const String& initDataType, PassRefPtr<ArrayBuffer> initData, const String& sessionType)
 {
@@ skipping 24 matching lines @@
 
 void MediaKeySessionInitializer::timerFired(Timer<MediaKeySessionInitializer>*)
 {
     WTF_LOG(Media, "MediaKeySessionInitializer::timerFired");
 
     // Continue MediaKeys::createSession() at step 7.
     // 7.1 Let request be null. (Request provided by cdm in message event).
     // 7.2 Let default URL be null. (Also provided by cdm in message event).
 
     // 7.3 Let cdm be the cdm loaded in create().
-    blink::WebContentDecryptionModule* cdm = m_mediaKeys->contentDecryptionModule();
+    WebContentDecryptionModule* cdm = m_mediaKeys->contentDecryptionModule();
 
     // 7.4 Use the cdm to execute the following steps:
     // 7.4.1 If the init data is not valid for initDataType, reject promise
     //       with a new DOMException whose name is "InvalidAccessError".
     // 7.4.2 If the init data is not supported by the cdm, reject promise with
     //       a new DOMException whose name is "NotSupportedError".
     // 7.4.3 Let request be a request (e.g. a license request) generated based
     //       on the init data, which is interpreteted per initDataType, and
     //       sessionType. If sessionType is "temporary", the request is for a
     //       temporary non-persisted license. If sessionType is "persistent",
     //       the request is for a persistable license.
     // 7.4.4 If the init data indicates a default URL, let default URL be
     //       that URL. The URL may be validated and/or normalized.
     m_cdmSession = adoptPtr(cdm->createSession());
     NewMediaKeySessionResult* result = new NewMediaKeySessionResult(this);
     m_cdmSession->initializeNewSession(m_initDataType, static_cast<unsigned char*>(m_initData->data()), m_initData->byteLength(), m_sessionType, result->result());
 
     WTF_LOG(Media, "MediaKeySessionInitializer::timerFired done");
     // Note: As soon as the promise is resolved (or rejected), the
     // ScriptPromiseResolver object (|this|) is freed. So if
     // initializeNewSession() is synchronous, access to any members will crash.
 }
 
-void MediaKeySessionInitializer::completeWithSession(blink::WebContentDecryptionModuleResult::SessionStatus status)
+void MediaKeySessionInitializer::completeWithSession(WebContentDecryptionModuleResult::SessionStatus status)
 {
     WTF_LOG(Media, "MediaKeySessionInitializer::completeWithSession");
 
     switch (status) {
-    case blink::WebContentDecryptionModuleResult::NewSession: {
+    case WebContentDecryptionModuleResult::NewSession: {
         // Resume MediaKeys::createSession().
         // 7.5 Let the session ID be a unique Session ID string. It may be
         //     obtained from cdm (it is).
         // 7.6 Let session be a new MediaKeySession object, and initialize it.
         //     (Object was created previously, complete the steps for 7.6).
         RefPtrWillBeRawPtr<MediaKeySession> session = adoptRefCountedGarbageCollectedWillBeNoop(new MediaKeySession(executionContext(), m_mediaKeys, m_cdmSession.release()));
         session->suspendIfNeeded();
 
         // 7.7 If any of the preceding steps failed, reject promise with a
         //     new DOMException whose name is the appropriate error name
         //     and that has an appropriate message.
         //     (Implemented by CDM/Chromium calling completeWithError()).
 
         // 7.8 Add an entry for the value of the sessionId attribute to the
         //     list of active session IDs for this object.
         //     (Implemented in SessionIdAdapter).
 
         // 7.9 Run the Queue a "message" Event algorithm on the session,
         //     providing request and default URL.
         //     (Done by the CDM).
 
         // 7.10 Resolve promise with session.
         resolve(session.release());
         WTF_LOG(Media, "MediaKeySessionInitializer::completeWithSession done w/session");
         return;
     }
 
-    case blink::WebContentDecryptionModuleResult::SessionNotFound:
+    case WebContentDecryptionModuleResult::SessionNotFound:
         // Step 4.7.1 of MediaKeys::loadSession(): If there is no data
         // stored for the sessionId in the origin, resolve promise with
         // undefined.
         resolve(V8UndefinedType());
         WTF_LOG(Media, "MediaKeySessionInitializer::completeWithSession done w/undefined");
         return;
 
-    case blink::WebContentDecryptionModuleResult::SessionAlreadyExists:
+    case WebContentDecryptionModuleResult::SessionAlreadyExists:
         // If a session already exists, resolve the promise with null.
         resolve(V8NullType());
         WTF_LOG(Media, "MediaKeySessionInitializer::completeWithSession done w/null");
         return;
     }
     ASSERT_NOT_REACHED();
 }
 
 void MediaKeySessionInitializer::completeWithDOMException(ExceptionCode code, const String& errorMessage)
 {
     WTF_LOG(Media, "MediaKeySessionInitializer::completeWithDOMException");
     reject(DOMException::create(code, errorMessage));
 }
 
 ScriptPromise MediaKeySession::create(ScriptState* scriptState, MediaKeys* mediaKeys, const String& initDataType, PassRefPtr<ArrayBuffer> initData, const String& sessionType)
 {
     // Since creation is done asynchronously, use MediaKeySessionInitializer
     // to do it.
     return MediaKeySessionInitializer::create(scriptState, mediaKeys, initDataType, initData, sessionType);
 }
 
-MediaKeySession::MediaKeySession(ExecutionContext* context, MediaKeys* keys, PassOwnPtr<blink::WebContentDecryptionModuleSession> cdmSession)
+MediaKeySession::MediaKeySession(ExecutionContext* context, MediaKeys* keys, PassOwnPtr<WebContentDecryptionModuleSession> cdmSession)
     : ActiveDOMObject(context)
     , m_keySystem(keys->keySystem())
     , m_asyncEventQueue(GenericEventQueue::create(this))
     , m_session(cdmSession)
     , m_keys(keys)
     , m_isClosed(false)
     , m_closedPromise(new ClosedPromise(context, this, ClosedPromise::Closed))
     , m_actionTimer(this, &MediaKeySession::actionTimerFired)
 {
     WTF_LOG(Media, "MediaKeySession(%p)::MediaKeySession", this);
@@ skipping 153 matching lines @@
             break;
         case PendingAction::Message:
             WTF_LOG(Media, "MediaKeySession(%p)::actionTimerFired: Message", this);
             m_asyncEventQueue->enqueueEvent(action->event().release());
             break;
         }
     }
 }
 
 // Queue a task to fire a simple event named keymessage at the new object
-void MediaKeySession::message(const unsigned char* message, size_t messageLength, const blink::WebURL& destinationURL)
+void MediaKeySession::message(const unsigned char* message, size_t messageLength, const WebURL& destinationURL)
 {
     WTF_LOG(Media, "MediaKeySession(%p)::message", this);
 
     MediaKeyMessageEventInit init;
     init.bubbles = false;
     init.cancelable = false;
     init.message = ArrayBuffer::create(static_cast<const void*>(message), messageLength);
     init.destinationURL = destinationURL.string();
 
     RefPtrWillBeRawPtr<MediaKeyMessageEvent> event = MediaKeyMessageEvent::create(EventTypeNames::message, init);
@@ skipping 57 matching lines @@
     //    systemCode = a Key System-specific value, if provided, and 0 otherwise
     // 2. Set the MediaKeySession object's error attribute to the error object created in the previous step.
     m_error = MediaKeyError::create(mediaKeyErrorCode, systemCode);
 
     // 3. queue a task to fire a simple event named keyerror at the MediaKeySession object.
     RefPtrWillBeRawPtr<Event> event = Event::create(EventTypeNames::error);
     event->setTarget(this);
     m_asyncEventQueue->enqueueEvent(event.release());
 }
 
-void MediaKeySession::error(blink::WebContentDecryptionModuleException exception, unsigned long systemCode, const blink::WebString& errorMessage)
+void MediaKeySession::error(WebContentDecryptionModuleException exception, unsigned long systemCode, const WebString& errorMessage)
 {
     WTF_LOG(Media, "MediaKeySession::error: exception=%d, systemCode=%lu", exception, systemCode);
 
     // FIXME: EME-WD MediaKeyError now derives from DOMException. Figure out how
     // to implement this without breaking prefixed EME, which has a totally
     // different definition. The spec may also change to be just a DOMException.
     // For now, simply generate an existing MediaKeyError.
     MediaKeyErrorCode errorCode;
     switch (exception) {
-    case blink::WebContentDecryptionModuleExceptionClientError:
+    case WebContentDecryptionModuleExceptionClientError:
         errorCode = MediaKeyErrorCodeClient;
         break;
     default:
         // All other exceptions get converted into Unknown.
         errorCode = MediaKeyErrorCodeUnknown;
         break;
     }
     error(errorCode, systemCode);
 }
 
@@ skipping 38 matching lines @@
 void MediaKeySession::trace(Visitor* visitor)
 {
     visitor->trace(m_error);
     visitor->trace(m_asyncEventQueue);
     visitor->trace(m_pendingActions);
     visitor->trace(m_keys);
     visitor->trace(m_closedPromise);
     EventTargetWithInlineData::trace(visitor);
 }
 
-}
+} // namespace blink