Encrypted Media: Implement IPC based SetCdm().

content/renderer/media/android/webmediaplayer_android.cc

 // Copyright 2013 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 "content/renderer/media/android/webmediaplayer_android.h"
 
 #include <limits>
 
 #include "base/bind.h"
 #include "base/callback_helpers.h"
 #include "base/command_line.h"
 #include "base/files/file_path.h"
 #include "base/logging.h"
 #include "base/message_loop/message_loop.h"
 #include "base/metrics/histogram.h"
 #include "base/strings/string_number_conversions.h"
 #include "cc/layers/video_layer.h"
 #include "content/public/common/content_client.h"
 #include "content/public/renderer/render_frame.h"
 #include "content/renderer/media/android/proxy_media_keys.h"

[ddorwin, 2014/03/11 18:05:14]

Remove - ProxyMediaKeys is not used.
We will temporarily need media_keys.h, but we should have a TODO to remove it
with the prefixed APIs.
(Probably ditto in WMPI.)

[xhwang, 2014/03/12 01:07:52]

Done.

 #include "content/renderer/media/android/renderer_demuxer_android.h"
 #include "content/renderer/media/android/renderer_media_player_manager.h"
 #include "content/renderer/media/crypto/key_systems.h"
+#include "content/renderer/media/webcontentdecryptionmodule_impl.h"
 #include "content/renderer/media/webmediaplayer_delegate.h"
 #include "content/renderer/media/webmediaplayer_util.h"
 #include "content/renderer/render_frame_impl.h"
 #include "content/renderer/render_thread_impl.h"
 #include "gpu/GLES2/gl2extchromium.h"
 #include "gpu/command_buffer/client/gles2_interface.h"
 #include "gpu/command_buffer/common/mailbox_holder.h"
 #include "grit/content_resources.h"
 #include "media/base/android/media_player_android.h"
 #include "media/base/bind_to_current_loop.h"
@@ skipping 77 matching lines @@
       has_media_metadata_(false),
       has_media_info_(false),
       stream_texture_factory_(factory),
       needs_external_surface_(false),
       video_frame_provider_client_(NULL),
       pending_playback_(false),
       player_type_(MEDIA_PLAYER_TYPE_URL),
       current_time_(0),
       is_remote_(false),
       media_log_(media_log),
+      web_cdm_(NULL),
       weak_factory_(this) {
   DCHECK(manager_);
 
   DCHECK(main_thread_checker_.CalledOnValidThread());
 
   player_id_ = manager_->RegisterMediaPlayer(this);
 
 #if defined(VIDEO_HOLE)
   // Defer stream texture creation until we are sure it's necessary.
   needs_establish_peer_ = false;
@@ skipping 1068 matching lines @@
 
   // We do not support run-time switching between key systems for now.
   if (current_key_system_.empty()) {
     if (!proxy_decryptor_) {
       proxy_decryptor_.reset(new ProxyDecryptor(
 #if defined(ENABLE_PEPPER_CDMS)
           client_,
           frame_,
 #else
           manager_,
-          player_id_,  // TODO(xhwang): Use cdm_id when MediaKeys are
-                       // separated from WebMediaPlayer.
+          player_id_,  // For prefixed EME API, the CDM ID is always the same
+                       // as the player ID.
 #endif  // defined(ENABLE_PEPPER_CDMS)
           base::Bind(&WebMediaPlayerAndroid::OnKeyAdded,
                      weak_factory_.GetWeakPtr()),
           base::Bind(&WebMediaPlayerAndroid::OnKeyError,
                      weak_factory_.GetWeakPtr()),
           base::Bind(&WebMediaPlayerAndroid::OnKeyMessage,
                      weak_factory_.GetWeakPtr())));
     }
 
     if (!proxy_decryptor_->InitializeCDM(key_system,
                                          frame_->document().url())) {
       return WebMediaPlayer::MediaKeyExceptionKeySystemNotSupported;
     }
 
-    if (proxy_decryptor_ && !decryptor_ready_cb_.is_null()) {
+    if (!decryptor_ready_cb_.is_null()) {

[ddorwin, 2014/03/11 04:06:33]

This is only for CK now?

[xhwang, 2014/03/12 01:07:52]

Yes.

       base::ResetAndReturn(&decryptor_ready_cb_)
           .Run(proxy_decryptor_->GetDecryptor());

[ddorwin, 2014/03/11 04:06:33]

proxy_decryptor_ will never be NULL in this case? (The check was removed.)

[xhwang, 2014/03/12 01:07:52]

Yes, see line 1205 and 1227.

     }
 
+    int cdm_id = proxy_decryptor_->GetCdmId();

[ddorwin, 2014/03/11 04:06:33]

Do you still want to run this for CK?

[xhwang, 2014/03/12 01:07:52]

Here we don't have key system specific info. We can use
|decryptor_ready_cb_.is_null()| but that's not reliable: when
decryptor_ready_cb_.is_null() we may still be using clearkey; the pipeline takes
some time to initialize and request a decryptor. So here I am trying to keep
these two paths orthogonal.

+    if (cdm_id != media::MediaKeys::kInvalidCdmId) {
+      DCHECK_EQ(player_id_, cdm_id) << "In prefixed EME, CDM ID == player ID.";
+      manager_->SetMediaKeys(player_id_, cdm_id);
+    }
+
     current_key_system_ = key_system;
   } else if (key_system != current_key_system_) {
     return WebMediaPlayer::MediaKeyExceptionInvalidPlayerState;
   }
 
   // TODO(xhwang): We assume all streams are from the same container (thus have
   // the same "type") for now. In the future, the "type" should be passed down
   // from the application.
   if (!proxy_decryptor_->GenerateKeyRequest(
            init_data_type_, init_data, init_data_length)) {
@@ skipping 75 matching lines @@
   if (!IsKeySystemSupported(key_system))
     return WebMediaPlayer::MediaKeyExceptionKeySystemNotSupported;
 
   if (current_key_system_.empty() || key_system != current_key_system_)
     return WebMediaPlayer::MediaKeyExceptionInvalidPlayerState;
 
   proxy_decryptor_->CancelKeyRequest(session_id);
   return WebMediaPlayer::MediaKeyExceptionNoError;
 }
 
+void WebMediaPlayerAndroid::setContentDecryptionModule(

[ddorwin, 2014/03/11 04:06:33]

PSA: When adding APIs on the Blink side, let's try to remember to update all the
WMP children with at least NOTREACHED or TODOs and bugs. WDYT?

[xhwang, 2014/03/12 01:07:52]

Agreed. My bad.

+    blink::WebContentDecryptionModule* cdm) {
+  DCHECK(main_loop_->BelongsToCurrentThread());
+
+  // TODO(xhwang): Support setMediaKeys(0) if necessary: http://crbug.com/330324

[ddorwin, 2014/03/11 04:06:33]

Just a thought: Maybe we should ask the CDM if it will allow it.

[xhwang, 2014/03/12 01:07:52]

sgtm. So setContentDecryptionModule() should return an exception?

[ddorwin, 2014/03/25 23:03:59]

Yes, but I think we might need an explicit call since setMediaKeys() will likely
start a task (https://www.w3.org/Bugs/Public/show_bug.cgi?id=24216).

+  if (!cdm)
+    return;
+
+  web_cdm_ = ToWebContentDecryptionModuleImpl(cdm);
+  if (!web_cdm_)
+    return;
+
+  if (!decryptor_ready_cb_.is_null())
+    base::ResetAndReturn(&decryptor_ready_cb_).Run(web_cdm_->GetDecryptor());
+
+  int cdm_id = web_cdm_->GetCdmId();

[ddorwin, 2014/03/11 04:06:33]

ditto about CK

[xhwang, 2014/03/12 01:07:52]

ditto.

+  if (cdm_id != media::MediaKeys::kInvalidCdmId)
+    manager_->SetMediaKeys(player_id_, cdm_id);

[xhwang, 2014/03/10 23:35:40]

This is kind of ugly; we'll need some cleanup. But this is the easiest we can
have now. Let me know what you think about it :)

[ddorwin, 2014/03/11 04:06:33]

What in particular (that I haven't mentioned)?
I think this function should be called on load, which means we shouldn't need to
store the pending map.

[ddorwin, 2014/03/11 18:05:14]

I'm not sure that SetMediaKeys is the right term. We're setting the CDM or
decryptor to be used by the media player. Note that MediaKeys is not actually
exposed to WMPA/WMPI prior to this CL, except for the KeyError enum in the
legacy OnKeyError.

SetCdm is probably the better name, especially since it's the CDM ID we're
passing. This also means we should not be using MediaKeys::kInvalidCdmId.

[xhwang, 2014/03/12 01:07:52]

Renamed.

[xhwang, 2014/03/12 01:07:52]

I was talking about having two ways to setMediaKeys: SetCdm() and
decryptor_ready_cb_.Run(). That's requires some larger scale refactoring which
I'd like to think more about it and do it later.

You are right about no need to have the pending map.

+}
+
 void WebMediaPlayerAndroid::OnKeyAdded(const std::string& session_id) {
   EmeUMAHistogramCounts(current_key_system_, "KeyAdded", 1);
 
   client_->keyAdded(
       WebString::fromUTF8(GetPrefixedKeySystemName(current_key_system_)),
       WebString::fromUTF8(session_id));
 }
 
 void WebMediaPlayerAndroid::OnKeyError(const std::string& session_id,
                                        media::MediaKeys::KeyError error_code,
@@ skipping 68 matching lines @@
     return;
   }
 
   // TODO(xhwang): Support multiple decryptor notification request (e.g. from
   // video and audio). The current implementation is okay for the current
   // media pipeline since we initialize audio and video decoders in sequence.
   // But WebMediaPlayerImpl should not depend on media pipeline's implementation
   // detail.
   DCHECK(decryptor_ready_cb_.is_null());
 
+  // Mixed use of prefixed and unprefixed EME APIs is disallowed by Blink.
+  DCHECK(!(proxy_decryptor_ && web_cdm_));

[ddorwin, 2014/03/11 04:06:33]

nit: simplify to ! || !

[xhwang, 2014/03/12 01:07:52]

Done.

+
   if (proxy_decryptor_) {
     decryptor_ready_cb.Run(proxy_decryptor_->GetDecryptor());
     return;
   }
 
-  // TODO(xhwang): Also notify |web_cdm_| when we implement
-  // setContentDecryptionModule(). See: http://crbug.com/224786
+  if (web_cdm_) {
+    decryptor_ready_cb.Run(web_cdm_->GetDecryptor());

[ddorwin, 2014/03/11 04:06:33]

not really just used by CK?

[xhwang, 2014/03/12 01:07:52]

ditto

+    return;
+  }
 
   decryptor_ready_cb_ = decryptor_ready_cb;
 }
 
 void WebMediaPlayerAndroid::DoReleaseRemotePlaybackTexture(uint32 sync_point) {
   DCHECK(main_thread_checker_.CalledOnValidThread());
   DCHECK(remote_playback_texture_id_);
 
   GLES2Interface* gl = stream_texture_factory_->ContextGL();
 
@@ skipping 12 matching lines @@
 
 void WebMediaPlayerAndroid::exitFullscreen() {
   manager_->ExitFullscreen(player_id_);
 }
 
 bool WebMediaPlayerAndroid::canEnterFullscreen() const {
   return manager_->CanEnterFullscreen(frame_);
 }
 
 }  // namespace content