Separate CDM initialization from GenerateKeyRequest & remove key_system parameters.

webkit/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 "webkit/renderer/media/webmediaplayer_impl.h"
 
 #include <algorithm>
 #include <limits>
 #include <string>
 #include <vector>
@@ skipping 28 matching lines @@
 #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/WebMediaSource.h"
 #include "third_party/WebKit/public/web/WebRuntimeFeatures.h"
 #include "third_party/WebKit/public/web/WebView.h"
 #include "v8/include/v8.h"
 #include "webkit/plugins/ppapi/ppapi_webplugin_impl.h"
 #include "webkit/renderer/compositor_bindings/web_layer_impl.h"
 #include "webkit/renderer/media/buffered_data_source.h"
+#include "webkit/renderer/media/crypto/key_systems.h"
 #include "webkit/renderer/media/texttrack_impl.h"
 #include "webkit/renderer/media/webaudiosourceprovider_impl.h"
 #include "webkit/renderer/media/webinbandtexttrack_impl.h"
 #include "webkit/renderer/media/webmediaplayer_delegate.h"
 #include "webkit/renderer/media/webmediaplayer_params.h"
 #include "webkit/renderer/media/webmediaplayer_util.h"
 #include "webkit/renderer/media/webmediasourceclient_impl.h"
 
 using WebKit::WebCanvas;
 using WebKit::WebMediaPlayer;
@@ skipping 624 matching lines @@
       GenerateKeyRequestInternal(key_system, init_data, init_data_length);
   ReportMediaKeyExceptionToUMA("generateKeyRequest", key_system, e);
   return e;
 }
 
 WebMediaPlayer::MediaKeyException
 WebMediaPlayerImpl::GenerateKeyRequestInternal(
     const WebString& key_system,
     const unsigned char* init_data,
     unsigned init_data_length) {
+  DVLOG(1) << "generateKeyRequest: " << key_system.utf8().data() << ": "
+           << std::string(reinterpret_cast<const char*>(init_data),
+                          static_cast<size_t>(init_data_length));
+
   if (!IsSupportedKeySystem(key_system))
     return WebMediaPlayer::MediaKeyExceptionKeySystemNotSupported;
 
   // We do not support run-time switching between key systems for now.
-  if (current_key_system_.isEmpty())
+  if (current_key_system_.isEmpty()) {
+    if (!decryptor_->InitializeCDM(key_system.utf8()))
+      return WebMediaPlayer::MediaKeyExceptionKeySystemNotSupported;
     current_key_system_ = key_system;
-  else if (key_system != current_key_system_)
+  }
+  else if (key_system != current_key_system_) {
     return WebMediaPlayer::MediaKeyExceptionInvalidPlayerState;
-
-  DVLOG(1) << "generateKeyRequest: " << key_system.utf8().data() << ": "
-           << std::string(reinterpret_cast<const char*>(init_data),
-                          static_cast<size_t>(init_data_length));
+  }
 
   // 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 (!decryptor_->GenerateKeyRequest(key_system.utf8(),
-                                      init_data_type_,
+  if (!decryptor_->GenerateKeyRequest(init_data_type_,
                                       init_data, init_data_length)) {
     current_key_system_.reset();
     return WebMediaPlayer::MediaKeyExceptionKeySystemNotSupported;
   }
 
   return WebMediaPlayer::MediaKeyExceptionNoError;
 }
 
 WebMediaPlayer::MediaKeyException WebMediaPlayerImpl::addKey(
     const WebString& key_system,
@@ skipping 10 matching lines @@
 
 WebMediaPlayer::MediaKeyException WebMediaPlayerImpl::AddKeyInternal(
     const WebString& key_system,
     const unsigned char* key,
     unsigned key_length,
     const unsigned char* init_data,
     unsigned init_data_length,
     const WebString& session_id) {
   DCHECK(key);
   DCHECK_GT(key_length, 0u);
-
-  if (!IsSupportedKeySystem(key_system))
-    return WebMediaPlayer::MediaKeyExceptionKeySystemNotSupported;
-
-  if (current_key_system_.isEmpty() || key_system != current_key_system_)
-    return WebMediaPlayer::MediaKeyExceptionInvalidPlayerState;
-
   DVLOG(1) << "addKey: " << key_system.utf8().data() << ": "
            << std::string(reinterpret_cast<const char*>(key),
                           static_cast<size_t>(key_length)) << ", "
            << std::string(reinterpret_cast<const char*>(init_data),
                           static_cast<size_t>(init_data_length))
            << " [" << session_id.utf8().data() << "]";
 
-  decryptor_->AddKey(key_system.utf8(), key, key_length,
+
+  if (!IsSupportedKeySystem(key_system))
+    return WebMediaPlayer::MediaKeyExceptionKeySystemNotSupported;
+
+  if (current_key_system_.isEmpty() || key_system != current_key_system_)
+    return WebMediaPlayer::MediaKeyExceptionInvalidPlayerState;
+
+  decryptor_->AddKey(key, key_length,
                      init_data, init_data_length, session_id.utf8());
   return WebMediaPlayer::MediaKeyExceptionNoError;
 }
 
 WebMediaPlayer::MediaKeyException WebMediaPlayerImpl::cancelKeyRequest(
     const WebString& key_system,
     const WebString& session_id) {
   WebMediaPlayer::MediaKeyException e =
       CancelKeyRequestInternal(key_system, session_id);
   ReportMediaKeyExceptionToUMA("cancelKeyRequest", key_system, e);
   return e;
 }
 
 WebMediaPlayer::MediaKeyException
 WebMediaPlayerImpl::CancelKeyRequestInternal(
     const WebString& key_system,
     const WebString& session_id) {
   if (!IsSupportedKeySystem(key_system))
     return WebMediaPlayer::MediaKeyExceptionKeySystemNotSupported;
 
   if (current_key_system_.isEmpty() || key_system != current_key_system_)
     return WebMediaPlayer::MediaKeyExceptionInvalidPlayerState;
 
-  decryptor_->CancelKeyRequest(key_system.utf8(), session_id.utf8());
+  decryptor_->CancelKeyRequest(session_id.utf8());
   return WebMediaPlayer::MediaKeyExceptionNoError;
 }
 
 void WebMediaPlayerImpl::WillDestroyCurrentMessageLoop() {
   Destroy();
 }
 
 void WebMediaPlayerImpl::Repaint() {
   DCHECK(main_loop_->BelongsToCurrentThread());
 
@@ skipping 82 matching lines @@
   Repaint();
 }
 
 void WebMediaPlayerImpl::OnDemuxerOpened(
     scoped_ptr<WebKit::WebMediaSource> media_source) {
   DCHECK(main_loop_->BelongsToCurrentThread());
   media_source->open(new WebMediaSourceClientImpl(
       chunk_demuxer_, base::Bind(&LogMediaSourceError, media_log_)));
 }
 
-void WebMediaPlayerImpl::OnKeyAdded(const std::string& key_system,
-                                    const std::string& session_id) {
+void WebMediaPlayerImpl::OnKeyAdded(const std::string& session_id) {
   DCHECK(main_loop_->BelongsToCurrentThread());
-  EmeUMAHistogramCounts(key_system, "KeyAdded", 1);
-  GetClient()->keyAdded(WebString::fromUTF8(key_system),
+  EmeUMAHistogramCounts(current_key_system_.utf8(), "KeyAdded", 1);
+  GetClient()->keyAdded(current_key_system_,
                         WebString::fromUTF8(session_id));
 }
 
-void WebMediaPlayerImpl::OnNeedKey(const std::string& key_system,
-                                   const std::string& session_id,
+void WebMediaPlayerImpl::OnNeedKey(const std::string& session_id,
                                    const std::string& type,
                                    scoped_ptr<uint8[]> init_data,
                                    int init_data_size) {
   DCHECK(main_loop_->BelongsToCurrentThread());
 
   // Do not fire NeedKey event if encrypted media is not enabled.
   if (!decryptor_)
     return;
 
   UMA_HISTOGRAM_COUNTS(kMediaEme + std::string("NeedKey"), 1);
 
   DCHECK(init_data_type_.empty() || type.empty() || type == init_data_type_);
   if (init_data_type_.empty())
     init_data_type_ = type;
 
-  GetClient()->keyNeeded(WebString::fromUTF8(key_system),
+  GetClient()->keyNeeded(WebString(),
                          WebString::fromUTF8(session_id),
                          init_data.get(),
                          init_data_size);
 }
 
 scoped_ptr<media::TextTrack>
 WebMediaPlayerImpl::OnTextTrack(media::TextKind kind,
                                 const std::string& label,
                                 const std::string& language) {
   typedef WebInbandTextTrackImpl::Kind webkind_t;
   const webkind_t webkind = static_cast<webkind_t>(kind);
   const WebKit::WebString weblabel = WebKit::WebString::fromUTF8(label);
   const WebKit::WebString weblanguage = WebKit::WebString::fromUTF8(language);
 
   WebInbandTextTrackImpl* const text_track =
     new WebInbandTextTrackImpl(webkind, weblabel, weblanguage,
                                text_track_index_++);
   GetClient()->addTextTrack(text_track);
 
   return scoped_ptr<media::TextTrack>(new TextTrackImpl(text_track));
 }
 
-void WebMediaPlayerImpl::OnKeyError(const std::string& key_system,
-                                    const std::string& session_id,
+void WebMediaPlayerImpl::OnKeyError(const std::string& session_id,
                                     media::MediaKeys::KeyError error_code,
                                     int system_code) {
   DCHECK(main_loop_->BelongsToCurrentThread());
 
-  EmeUMAHistogramEnumeration(
-      key_system, "KeyError", error_code, media::MediaKeys::kMaxKeyError);
+  EmeUMAHistogramEnumeration(current_key_system_.utf8(), "KeyError",
+                             error_code, media::MediaKeys::kMaxKeyError);
 
   GetClient()->keyError(
-      WebString::fromUTF8(key_system),
+      current_key_system_,
       WebString::fromUTF8(session_id),
       static_cast<WebKit::WebMediaPlayerClient::MediaKeyErrorCode>(error_code),
       system_code);
 }
 
-void WebMediaPlayerImpl::OnKeyMessage(const std::string& key_system,
-                                      const std::string& session_id,
+void WebMediaPlayerImpl::OnKeyMessage(const std::string& session_id,
                                       const std::string& message,
                                       const std::string& default_url) {
   DCHECK(main_loop_->BelongsToCurrentThread());
 
   const GURL default_url_gurl(default_url);
   DLOG_IF(WARNING, !default_url.empty() && !default_url_gurl.is_valid())
       << "Invalid URL in default_url: " << default_url;
 
-  GetClient()->keyMessage(WebString::fromUTF8(key_system),
+  GetClient()->keyMessage(current_key_system_,
                           WebString::fromUTF8(session_id),
                           reinterpret_cast<const uint8*>(message.data()),
                           message.size(),
                           default_url_gurl);
 }
 
 void WebMediaPlayerImpl::SetOpaque(bool opaque) {
   DCHECK(main_loop_->BelongsToCurrentThread());
 
   GetClient()->setOpaque(opaque);
@@ skipping 29 matching lines @@
   // Keep track if this is a MSE or non-MSE playback.
   UMA_HISTOGRAM_BOOLEAN("Media.MSE.Playback", (media_source != NULL));
 
   // Figure out which demuxer to use.
   if (!media_source) {
     DCHECK(!chunk_demuxer_);
     DCHECK(data_source_);
 
     demuxer_.reset(new media::FFmpegDemuxer(
         media_loop_, data_source_.get(),
-        BIND_TO_RENDER_LOOP_2(&WebMediaPlayerImpl::OnNeedKey, "", "")));
+        BIND_TO_RENDER_LOOP_1(&WebMediaPlayerImpl::OnNeedKey, "")));
   } else {
     DCHECK(!chunk_demuxer_);
     DCHECK(!data_source_);
 
     scoped_ptr<WebKit::WebMediaSource> ms(media_source);
     chunk_demuxer_ = new media::ChunkDemuxer(
         BIND_TO_RENDER_LOOP_1(&WebMediaPlayerImpl::OnDemuxerOpened,
                               base::Passed(&ms)),
-        BIND_TO_RENDER_LOOP_2(&WebMediaPlayerImpl::OnNeedKey, "", ""),
+        BIND_TO_RENDER_LOOP_1(&WebMediaPlayerImpl::OnNeedKey, ""),
         base::Bind(&WebMediaPlayerImpl::OnTextTrack, base::Unretained(this)),
         base::Bind(&LogMediaSourceError, media_log_));
     demuxer_.reset(chunk_demuxer_);
 
     // Disable GpuVideoDecoder creation until it supports codec config changes.
     // TODO(acolwell): Remove this once http://crbug.com/151045 is fixed.
     gpu_factories_ = NULL;
 
     // Disable preroll increases on underflow since the web application has no
     // way to detect that this is happening and runs the risk of triggering
@@ skipping 170 matching lines @@
 
   if (pending_repaint_)
     return;
 
   pending_repaint_ = true;
   main_loop_->PostTask(FROM_HERE, base::Bind(
       &WebMediaPlayerImpl::Repaint, AsWeakPtr()));
 }
 
 }  // namespace webkit_media