Separate CDM initialization from GenerateKeyRequest & remove key_system parameters.

webkit/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 "webkit/renderer/media/android/webmediaplayer_android.h"
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/files/file_path.h"
 #include "base/logging.h"
@@ skipping 886 matching lines @@
       GenerateKeyRequestInternal(key_system, init_data, init_data_length);
   ReportMediaKeyExceptionToUMA("generateKeyRequest", key_system, e);
   return e;
 }
 
 WebMediaPlayer::MediaKeyException
 WebMediaPlayerAndroid::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 defined(GOOGLE_TV)
+    if (!decryptor_->InitializeCDM(key_system.utf8()))
+      return WebMediaPlayer::MediaKeyExceptionKeySystemNotSupported;
+#endif  // defined(GOOGLE_TV
     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));
+  }
 
 #if defined(GOOGLE_TV)
   // 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_,
                                       init_data, init_data_length)) {
     current_key_system_.reset();
     return WebMediaPlayer::MediaKeyExceptionKeySystemNotSupported;
   }
 #else
   proxy_->GenerateKeyRequest(
       player_id_,
-      key_system.utf8(),
       init_data_type_,
       std::vector<uint8>(init_data, init_data + init_data_length));
 #endif  // defined(GOOGLE_TV)
 
   return WebMediaPlayer::MediaKeyExceptionNoError;
 }
 
 WebMediaPlayer::MediaKeyException WebMediaPlayerAndroid::addKey(
     const WebString& key_system,
     const unsigned char* key,
     unsigned key_length,
     const unsigned char* init_data,
     unsigned init_data_length,
     const WebString& session_id) {
   WebMediaPlayer::MediaKeyException e = AddKeyInternal(
       key_system, key, key_length, init_data, init_data_length, session_id);
   ReportMediaKeyExceptionToUMA("addKey", key_system, e);
   return e;
 }
 
 WebMediaPlayer::MediaKeyException WebMediaPlayerAndroid::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() << "]";
 
+  if (!IsSupportedKeySystem(key_system))
+    return WebMediaPlayer::MediaKeyExceptionKeySystemNotSupported;
+
+  if (current_key_system_.isEmpty() || key_system != current_key_system_)
+    return WebMediaPlayer::MediaKeyExceptionInvalidPlayerState;
+
 #if defined(GOOGLE_TV)
-  decryptor_->AddKey(key_system.utf8(), key, key_length,
-                     init_data, init_data_length, session_id.utf8());
+  decryptor_->AddKey(key, key_length, init_data, init_data_length,
+                     session_id.utf8());
 #else
   proxy_->AddKey(player_id_,
-                 key_system.utf8(),
                  std::vector<uint8>(key, key + key_length),
                  std::vector<uint8>(init_data, init_data + init_data_length),
                  session_id.utf8());
 #endif  // #if defined(GOOGLE_TV)
 
   return WebMediaPlayer::MediaKeyExceptionNoError;
 }
 
 WebMediaPlayer::MediaKeyException WebMediaPlayerAndroid::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
 WebMediaPlayerAndroid::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;
 
 #if defined(GOOGLE_TV)
-  decryptor_->CancelKeyRequest(key_system.utf8(), session_id.utf8());
+  decryptor_->CancelKeyRequest(session_id.utf8());
 #else
-  proxy_->CancelKeyRequest(player_id_, key_system.utf8(), session_id.utf8());
+  proxy_->CancelKeyRequest(player_id_, session_id.utf8());
 #endif  // #if defined(GOOGLE_TV)
 
   return WebMediaPlayer::MediaKeyExceptionNoError;
 }
 
-void WebMediaPlayerAndroid::OnKeyAdded(const std::string& key_system,
-                                       const std::string& session_id) {
-  EmeUMAHistogramCounts(key_system, "KeyAdded", 1);
+void WebMediaPlayerAndroid::OnKeyAdded(const std::string& session_id) {
+  EmeUMAHistogramCounts(current_key_system_.utf8(), "KeyAdded", 1);
 
   if (media_source_delegate_)
-    media_source_delegate_->NotifyDemuxerReady(key_system);
+    media_source_delegate_->NotifyDemuxerReady(current_key_system_.utf8());
 
-  client_->keyAdded(WebString::fromUTF8(key_system),
-                    WebString::fromUTF8(session_id));
+  client_->keyAdded(current_key_system_, WebString::fromUTF8(session_id));
 }
 
-void WebMediaPlayerAndroid::OnKeyError(const std::string& key_system,
-                                       const std::string& session_id,
+void WebMediaPlayerAndroid::OnKeyError(const std::string& session_id,
                                        media::MediaKeys::KeyError error_code,
                                        int system_code) {
-  EmeUMAHistogramEnumeration(
-      key_system, "KeyError", error_code, media::MediaKeys::kMaxKeyError);
+  EmeUMAHistogramEnumeration(current_key_system_.utf8(), "KeyError",
+                             error_code, media::MediaKeys::kMaxKeyError);
 
   client_->keyError(
-      WebString::fromUTF8(key_system),
+      current_key_system_,
       WebString::fromUTF8(session_id),
       static_cast<WebKit::WebMediaPlayerClient::MediaKeyErrorCode>(error_code),
       system_code);
 }
 
-void WebMediaPlayerAndroid::OnKeyMessage(const std::string& key_system,
-                                         const std::string& session_id,
+void WebMediaPlayerAndroid::OnKeyMessage(const std::string& session_id,
                                          const std::string& message,
                                          const std::string& destination_url) {
   const GURL destination_url_gurl(destination_url);
   DLOG_IF(WARNING, !destination_url.empty() && !destination_url_gurl.is_valid())
       << "Invalid URL in destination_url: " << destination_url;
 
-  client_->keyMessage(WebString::fromUTF8(key_system),
+  client_->keyMessage(current_key_system_,
                       WebString::fromUTF8(session_id),
                       reinterpret_cast<const uint8*>(message.data()),
                       message.size(),
                       destination_url_gurl);
 }
 
-void WebMediaPlayerAndroid::OnNeedKey(const std::string& key_system,
-                                      const std::string& session_id,
+void WebMediaPlayerAndroid::OnNeedKey(const std::string& session_id,
                                       const std::string& type,
                                       scoped_ptr<uint8[]> init_data,
                                       int init_data_size) {
   // Do not fire NeedKey event if encrypted media is not enabled.
   if (!WebKit::WebRuntimeFeatures::isEncryptedMediaEnabled() &&
       !WebKit::WebRuntimeFeatures::isLegacyEncryptedMediaEnabled()) {
     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;
 
-  client_->keyNeeded(WebString::fromUTF8(key_system),
+  client_->keyNeeded(WebString(),
                      WebString::fromUTF8(session_id),
                      init_data.get(),
                      init_data_size);
 }
 
 #if defined(GOOGLE_TV)
 bool WebMediaPlayerAndroid::InjectMediaStream(
     MediaStreamClient* media_stream_client,
     media::Demuxer* demuxer,
     const base::Closure& destroy_demuxer_cb) {
@@ skipping 22 matching lines @@
 
 void WebMediaPlayerAndroid::exitFullscreen() {
   proxy_->ExitFullscreen(player_id_);
 }
 
 bool WebMediaPlayerAndroid::canEnterFullscreen() const {
   return manager_->CanEnterFullscreen(frame_);
 }
 
 }  // namespace webkit_media