Allow setContentDecryptionModule() to get called when setting is done.

content/renderer/media/webmediaplayer_impl.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/webmediaplayer_impl.h"
 
 #include <algorithm>
 #include <limits>
 #include <string>
 #include <vector>
@@ skipping 43 matching lines @@
 #include "media/filters/chunk_demuxer.h"
 #include "media/filters/ffmpeg_audio_decoder.h"
 #include "media/filters/ffmpeg_demuxer.h"
 #include "media/filters/ffmpeg_video_decoder.h"
 #include "media/filters/gpu_video_accelerator_factories.h"
 #include "media/filters/gpu_video_decoder.h"
 #include "media/filters/opus_audio_decoder.h"
 #include "media/filters/video_renderer_impl.h"
 #include "media/filters/vpx_video_decoder.h"
 #include "third_party/WebKit/public/platform/WebContentDecryptionModule.h"
+#include "third_party/WebKit/public/platform/WebContentDecryptionModuleResult.h"
 #include "third_party/WebKit/public/platform/WebMediaSource.h"
 #include "third_party/WebKit/public/platform/WebRect.h"
 #include "third_party/WebKit/public/platform/WebSize.h"
 #include "third_party/WebKit/public/platform/WebString.h"
 #include "third_party/WebKit/public/platform/WebURL.h"
 #include "third_party/WebKit/public/web/WebDocument.h"
 #include "third_party/WebKit/public/web/WebLocalFrame.h"
 #include "third_party/WebKit/public/web/WebRuntimeFeatures.h"
 #include "third_party/WebKit/public/web/WebSecurityOrigin.h"
 #include "third_party/WebKit/public/web/WebView.h"
@@ skipping 702 matching lines @@
           BIND_TO_RENDER_LOOP(&WebMediaPlayerImpl::OnKeyError),
           BIND_TO_RENDER_LOOP(&WebMediaPlayerImpl::OnKeyMessage)));
     }
 
     GURL security_origin(frame_->document().securityOrigin().toString());
     if (!proxy_decryptor_->InitializeCDM(key_system, security_origin))
       return WebMediaPlayer::MediaKeyExceptionKeySystemNotSupported;
 
     if (proxy_decryptor_ && !decryptor_ready_cb_.is_null()) {
       base::ResetAndReturn(&decryptor_ready_cb_)
-          .Run(proxy_decryptor_->GetDecryptor());
+          .Run(proxy_decryptor_->GetDecryptor(), base::Bind(&base::DoNothing));
     }
 
     current_key_system_ = key_system;
   } else if (key_system != current_key_system_) {
     return WebMediaPlayer::MediaKeyExceptionInvalidPlayerState;
   }
 
   std::string init_data_type = init_data_type_;
   if (init_data_type.empty())
     init_data_type = GuessInitDataType(init_data, init_data_length);
@@ skipping 84 matching lines @@
   if (current_key_system_.empty() || key_system != current_key_system_)
     return WebMediaPlayer::MediaKeyExceptionInvalidPlayerState;
 
   proxy_decryptor_->CancelKeyRequest(session_id);
   return WebMediaPlayer::MediaKeyExceptionNoError;
 }
 
 void WebMediaPlayerImpl::setContentDecryptionModule(
     blink::WebContentDecryptionModule* cdm) {
   DCHECK(main_loop_->BelongsToCurrentThread());
+  // TODO(jrummell): Remove this method once blink starts calling with 2

[ddorwin, 2014/07/30 22:35:45]

Better in the header?

[jrummell, 2014/08/01 22:09:42]

Based in comments for the blink review, we may keep this method around. Removed
TODO.

+  // parameters.
 
   // TODO(xhwang): Support setMediaKeys(0) if necessary: http://crbug.com/330324
   if (!cdm)
     return;
 
   web_cdm_ = ToWebContentDecryptionModuleImpl(cdm);
 
   if (web_cdm_ && !decryptor_ready_cb_.is_null())
-    base::ResetAndReturn(&decryptor_ready_cb_).Run(web_cdm_->GetDecryptor());
+    base::ResetAndReturn(&decryptor_ready_cb_)
+        .Run(web_cdm_->GetDecryptor(), base::Bind(&base::DoNothing));
+}
+
+void WebMediaPlayerImpl::setContentDecryptionModule(
+    blink::WebContentDecryptionModule* cdm,
+    blink::WebContentDecryptionModuleResult result) {
+  DCHECK(main_loop_->BelongsToCurrentThread());
+
+  // TODO(xhwang): Support setMediaKeys(0) if necessary: http://crbug.com/330324
+  if (!cdm) {
+    result.completeWithError(
+        blink::WebContentDecryptionModuleExceptionNotSupportedError,
+        0,
+        "Setting a null MediaKeys object not supported.");

[ddorwin, 2014/07/30 22:35:45]

nit: s/not/is not/.
Or, to be more concise, just drop "Setting a ".

[jrummell, 2014/08/01 22:09:42]

Done.

+    return;
+  }
+
+  web_cdm_ = ToWebContentDecryptionModuleImpl(cdm);
+
+  if (web_cdm_ && !decryptor_ready_cb_.is_null()) {
+    base::ResetAndReturn(&decryptor_ready_cb_)
+        .Run(web_cdm_->GetDecryptor(),
+             BIND_TO_RENDER_LOOP1(
+                 &WebMediaPlayerImpl::ContentDecryptionModuleSet, result));
+  } else {
+    // No player, so setting CDM is complete.

[ddorwin, 2014/07/30 22:35:45]

I don't think this comment is correct. WMPI is the player.

web_cdm_ should not be NULL given line 912. That means the decryptor_ready_cb_
is null. How can that happen?

[jrummell, 2014/08/01 22:09:42]

Comment updated. decryptor_ready_cb_ is null if .src has not been specified yet.

+    ContentDecryptionModuleSet(result);
+  }
+}
+
+void WebMediaPlayerImpl::ContentDecryptionModuleSet(
+    blink::WebContentDecryptionModuleResult result) {
+  result.complete();
 }
 
 void WebMediaPlayerImpl::InvalidateOnMainThread() {
   DCHECK(main_loop_->BelongsToCurrentThread());
   TRACE_EVENT0("media", "WebMediaPlayerImpl::InvalidateOnMainThread");
 
   client_->repaint();
 }
 
 void WebMediaPlayerImpl::OnPipelineSeeked(bool time_changed,
@@ skipping 398 matching lines @@
                  frame));
 }
 
 void WebMediaPlayerImpl::SetDecryptorReadyCB(
      const media::DecryptorReadyCB& decryptor_ready_cb) {
   DCHECK(main_loop_->BelongsToCurrentThread());
 
   // Cancels the previous decryptor request.
   if (decryptor_ready_cb.is_null()) {
     if (!decryptor_ready_cb_.is_null())
-      base::ResetAndReturn(&decryptor_ready_cb_).Run(NULL);
+      base::ResetAndReturn(&decryptor_ready_cb_)
+          .Run(NULL, base::Bind(&base::DoNothing));

[ddorwin, 2014/07/30 22:35:45]

Don't we need to satisfy the promise in some way?

How can this happen?

[jrummell, 2014/08/01 22:09:42]

Here we are cancelling the previous request. There is no promise associated with
this.

     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_);
 
   if (proxy_decryptor_) {
-    decryptor_ready_cb.Run(proxy_decryptor_->GetDecryptor());
+    decryptor_ready_cb.Run(proxy_decryptor_->GetDecryptor(),
+                           base::Bind(&base::DoNothing));

[ddorwin, 2014/07/30 22:35:45]

prefixed only - so this is fine.

[jrummell, 2014/08/01 22:09:42]

Acknowledged.

     return;
   }
 
   if (web_cdm_) {
-    decryptor_ready_cb.Run(web_cdm_->GetDecryptor());
+    decryptor_ready_cb.Run(web_cdm_->GetDecryptor(),

[ddorwin, 2014/07/30 22:35:45]

Maybe comment that there can be no outstanding setMediaKeys() calls if web_cdm_.

That may not actually be true. The key is that there are no outstanding calls or
ContentDecryptionModuleSet is pending and does not need to be called again.

[jrummell, 2014/08/01 22:09:42]

Not sure what to comment here. setContentDecryptionModule() may have called
decryptor_ready_cb_ with the decryptor and it hasn't completed, but here we are
calling a different decryptor_ready_cb (with the same decryptor). If we saved
the WebContentDecryptionModuleResult, then calling it would be required here.
But currently we're not doing that.

The other interesting thing is that this gets called twice, once per stream. So
even if we "saved" the WebContentDecryptionModuleResult, it would only get
resolved when the first stream attaches to the decryptor.

+                           base::Bind(&base::DoNothing));
     return;
   }
 
   decryptor_ready_cb_ = decryptor_ready_cb;
 }
 
 static void GetCurrentFrameAndSignal(
     VideoFrameCompositor* compositor,
     scoped_refptr<media::VideoFrame>* video_frame_out,
     base::WaitableEvent* event) {
@@ skipping 15 matching lines @@
   compositor_task_runner_->PostTask(FROM_HERE,
                                     base::Bind(&GetCurrentFrameAndSignal,
                                                base::Unretained(compositor_),
                                                &video_frame,
                                                &event));
   event.Wait();
   return video_frame;
 }
 
 }  // namespace content