Move OnNeedKey() to WebMediaPlayerImpl.

media/blink/encrypted_media_player_support.cc

 // Copyright 2014 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 "media/blink/encrypted_media_player_support.h"
 
 #include <string>
 
 #include "base/bind.h"
 #include "base/callback_helpers.h"
 #include "base/metrics/histogram.h"
 #include "base/numerics/safe_conversions.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "media/base/bind_to_current_loop.h"
 #include "media/base/key_systems.h"
 #include "media/blink/webcontentdecryptionmodule_impl.h"
 #include "third_party/WebKit/public/platform/WebContentDecryptionModule.h"
 #include "third_party/WebKit/public/platform/WebMediaPlayerClient.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"
 
 using blink::WebMediaPlayer;
 using blink::WebMediaPlayerClient;
 using blink::WebString;
 
 namespace media {
 
 #define BIND_TO_RENDER_LOOP(function)            \
   (BindToCurrentLoop(base::Bind(function, AsWeakPtr())))
 
@@ skipping 97 matching lines @@
     const WebString& key_system,
     const unsigned char* init_data,
     unsigned init_data_length) {
   DVLOG(1) << "generateKeyRequest: " << base::string16(key_system) << ": "
            << std::string(reinterpret_cast<const char*>(init_data),
                           static_cast<size_t>(init_data_length));
 
   std::string ascii_key_system =
       GetUnprefixedKeySystemName(ToASCIIOrEmpty(key_system));
 
-  WebMediaPlayer::MediaKeyException e =
-      GenerateKeyRequestInternal(frame, ascii_key_system, init_data,
-                                 init_data_length);
+  WebMediaPlayer::MediaKeyException e = GenerateKeyRequestInternal(
+      frame, ascii_key_system, init_data, init_data_length);
   ReportMediaKeyExceptionToUMA("generateKeyRequest", ascii_key_system, e);
   return e;
 }
 
 WebMediaPlayer::MediaKeyException
 EncryptedMediaPlayerSupport::GenerateKeyRequestInternal(
     blink::WebLocalFrame* frame,
     const std::string& key_system,
     const unsigned char* init_data,
     unsigned init_data_length) {
@@ skipping 24 matching lines @@
 
     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);
 
-  // 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)) {
+  if (!proxy_decryptor_->GenerateKeyRequest(init_data_type, init_data,
+                                            init_data_length)) {
     current_key_system_.clear();
     return WebMediaPlayer::MediaKeyExceptionKeySystemNotSupported;
   }
 
   return WebMediaPlayer::MediaKeyExceptionNoError;
 }
 
 WebMediaPlayer::MediaKeyException EncryptedMediaPlayerSupport::AddKey(
     const WebString& key_system,
     const unsigned char* key,
@@ skipping 68 matching lines @@
   if (!IsConcreteSupportedKeySystem(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;
 }
 
-Demuxer::NeedKeyCB EncryptedMediaPlayerSupport::CreateNeedKeyCB() {
-  return BIND_TO_RENDER_LOOP(&EncryptedMediaPlayerSupport::OnNeedKey);
+void EncryptedMediaPlayerSupport::SetInitDataType(
+    const std::string& init_data_type) {
+  DCHECK(!init_data_type.empty());
+  DLOG_IF(WARNING,
+          !init_data_type_.empty() && init_data_type != init_data_type_)
+      << "Mixed init data type not supported. The new type is ignored.";
+  if (init_data_type_.empty())
+    init_data_type_ = init_data_type;
 }
 
 void EncryptedMediaPlayerSupport::OnPipelineDecryptError() {
   EmeUMAHistogramCounts(current_key_system_, "DecryptError", 1);
 }
 
-void EncryptedMediaPlayerSupport::OnNeedKey(
-    const std::string& type,
-    const std::vector<uint8>& init_data) {
-  // Do not fire NeedKey event if encrypted media is not enabled.
-  if (!blink::WebRuntimeFeatures::isPrefixedEncryptedMediaEnabled() &&
-      !blink::WebRuntimeFeatures::isEncryptedMediaEnabled()) {
-    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;
-
-  const uint8* init_data_ptr = init_data.empty() ? NULL : &init_data[0];
-  client_->encrypted(WebString::fromUTF8(type), init_data_ptr,
-                     base::saturated_cast<unsigned int>(init_data.size()));
-}
-
 void EncryptedMediaPlayerSupport::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 EncryptedMediaPlayerSupport::OnKeyError(const std::string& session_id,
                                              MediaKeys::KeyError error_code,
                                              uint32 system_code) {
@@ skipping 23 matching lines @@
 
   client_->keyMessage(
       WebString::fromUTF8(GetPrefixedKeySystemName(current_key_system_)),
       WebString::fromUTF8(session_id),
       message.empty() ? NULL : &message[0],
       base::saturated_cast<unsigned int>(message.size()),
       destination_url);
 }
 
 }  // namespace media