EME: Allow temporary sessions to be removed for ClearKey only.

third_party/WebKit/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 795 matching lines @@
   // 1. If this object is closed, return a promise rejected with an
   //    InvalidStateError.
   if (is_closed_)
     return CreateRejectedPromiseAlreadyClosed(script_state);
 
   // 2. If this object's callable value is false, return a promise rejected
   //    with an InvalidStateError.
   if (!is_callable_)
     return CreateRejectedPromiseNotCallable(script_state);
 
-  // 3. If the result of running the "Is persistent session type?" algorithm
-  //    on this object's session type is false, return a promise rejected
-  //    with a newly created TypeError.
-  if (!IsPersistentSessionType(session_type_)) {
-    return ScriptPromise::Reject(
-        script_state,
-        V8ThrowException::CreateTypeError(
-            script_state->GetIsolate(), "The session type is not persistent."));
-  }
-
-  // 4. Let promise be a new promise.
+  // 3. Let promise be a new promise.

[xhwang, 2017/04/21 18:00:28]

This change will also affect all key systems (e.g. Widevine) on all platforms. I
am not sure whether it's ready in those cases, e.g. WV on desktop/android,
ChromeCast, etc. And we probably should have browser tests covering those cases.

So, to avoid making this CL too big. Shall we limit this CL to only ClearKey?
Then we can fix it for Widevine in the next CL.

FWIW, to support WV on desktop, we need to update the CDM interface as well:
https://cs.chromium.org/chromium/src/media/cdm/api/content_decryption_module....

[jrummell, 2017/04/22 00:23:17]

Limited this to ClearKey only. Unfortunately there doesn't appear to be a common
place that knows about key_system and session type, so added
|is_persistent_session_| to webcontentdecryptionmodulesession_impl and checked
there.

   SimpleResultPromise* result = new SimpleResultPromise(script_state, this);
   ScriptPromise promise = result->Promise();
 
-  // 5. Run the following steps asynchronously (done in removeTask()).
+  // 4. Run the following steps asynchronously (done in removeTask()).
   pending_actions_.push_back(PendingAction::CreatePendingRemove(result));
   if (!action_timer_.IsActive())
     action_timer_.StartOneShot(0, BLINK_FROM_HERE);
 
-  // 6. Return promise.
+  // 5. Return promise.
   return promise;
 }
 
 void MediaKeySession::RemoveTask(ContentDecryptionModuleResult* result) {
-  // NOTE: Continue step 5 of MediaKeySession::remove().
+  // NOTE: Continue step 4 of MediaKeySession::remove().
   DVLOG(MEDIA_KEY_SESSION_LOG_LEVEL) << __func__ << "(" << this << ")";
 
-  // remove() in Chromium will execute steps 5.1 through 5.3.
+  // remove() in Chromium will execute steps 4.1 through 4.5.
   session_->Remove(result->Result());
 
-  // Last step (5.3.6 Resolve promise) will be done when |result| is resolved.
+  // Last step (4.5.6 Resolve promise) will be done when |result| is resolved.
 }
 
 void MediaKeySession::ActionTimerFired(TimerBase*) {
   DCHECK(pending_actions_.size());
 
   // Resolving promises now run synchronously and may result in additional
   // actions getting added to the queue. As a result, swap the queue to
   // a local copy to avoid problems if this happens.
   HeapDeque<Member<PendingAction>> pending_actions;
   pending_actions.Swap(pending_actions_);
@@ skipping 195 matching lines @@
   visitor->Trace(async_event_queue_);
   visitor->Trace(pending_actions_);
   visitor->Trace(media_keys_);
   visitor->Trace(key_statuses_map_);
   visitor->Trace(closed_promise_);
   EventTargetWithInlineData::Trace(visitor);
   ContextLifecycleObserver::Trace(visitor);
 }
 
 }  // namespace blink