Eliminate MediaPlayer & MediaPlayerClient abstractions

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/platform/WebMediaPlayerEncryptedMediaClient.h"
 #include "third_party/WebKit/public/web/WebDocument.h"
 #include "third_party/WebKit/public/web/WebLocalFrame.h"
 
 using blink::WebMediaPlayer;
 using blink::WebMediaPlayerClient;
+using blink::WebMediaPlayerEncryptedMediaClient;
 using blink::WebString;
 
 namespace media {
 
 #define BIND_TO_RENDER_LOOP(function)            \
   (BindToCurrentLoop(base::Bind(function, AsWeakPtr())))
 
 #define BIND_TO_RENDER_LOOP1(function, arg1)     \
   (BindToCurrentLoop(base::Bind(function, AsWeakPtr(), arg1)))
 
@@ skipping 71 matching lines @@
                                          unsigned init_data_length) {
   // Most WebM files use KeyId of 16 bytes. CENC init data is always >16 bytes.
   if (init_data_length == 16)
     return EmeInitDataType::WEBM;
 
   return EmeInitDataType::CENC;
 }
 
 EncryptedMediaPlayerSupport::EncryptedMediaPlayerSupport(
     CdmFactory* cdm_factory,
-    blink::WebMediaPlayerClient* client,
+    WebMediaPlayerClient* client,

[ddorwin, 2015/05/26 21:43:07]

I don't understand why we're passing this in.

If you need to adapt, do it at the higher levels (i.e. with a pass-through
adapter).

[Srirama, 2015/05/27 14:48:50]

To move encrypted related functions from WebMediaPlayerClient to
WebMediaPlayerEncryptedMediaClient, I need to remove them from
WebMediaPlayerClient on blink side and remove their invokation here, which will
be more than one step. So i am just trying to set up the path for
WebMediaPlayerEncryptedMediaClient for these functions before i can remove them
from WebMediaPlayerClient. So currently WebMediaPlayerEncryptedMediaClient will
be NULL which will be active when i land blink CL. At this point both client_
and encrypted_client_ will invoke these functions but client invokation is dummy
as i have kept empty functions in HTMLMediaElement. Now i will remove the client
invokation here and then i will remove blink side code.
Can you please elaborate a bit on what do you mean by pass-through. And whatever
problem i have explained above will be solved with pass-through approach you are
suggesting?

+    WebMediaPlayerEncryptedMediaClient* encrypted_client,
     MediaPermission* media_permission,
     const CdmContextReadyCB& cdm_context_ready_cb)
     : cdm_factory_(cdm_factory),
       client_(client),
+      encrypted_client_(encrypted_client),
       media_permission_(media_permission),
       init_data_type_(EmeInitDataType::UNKNOWN),
       cdm_context_ready_cb_(cdm_context_ready_cb) {
 }
 
 EncryptedMediaPlayerSupport::~EncryptedMediaPlayerSupport() {
 }
 
 WebMediaPlayer::MediaKeyException
 EncryptedMediaPlayerSupport::GenerateKeyRequest(
@@ skipping 143 matching lines @@
   if (init_data_type_ == EmeInitDataType::UNKNOWN)
     init_data_type_ = init_data_type;
 }
 
 void EncryptedMediaPlayerSupport::OnPipelineDecryptError() {
   EmeUMAHistogramCounts(current_key_system_, "DecryptError", 1);
 }
 
 void EncryptedMediaPlayerSupport::OnKeyAdded(const std::string& session_id) {
   EmeUMAHistogramCounts(current_key_system_, "KeyAdded", 1);
   client_->keyAdded(

[ddorwin, 2015/05/26 21:43:07]

This would result in two events if the encrypted_client_ is passed.
Also, what's the path to eliminating client_?

[Srirama, 2015/05/27 14:48:50]

The client_ event will be dummy as i have kept empty definitions in
HTMLMediaElement and i will eliminate this in two steps as i have explained
above. First i will remove the invokation here once encrypted_client_ is passed
and then remove them from HTMLMediaElement and WebMediaPlayerClient.

       WebString::fromUTF8(GetPrefixedKeySystemName(current_key_system_)),
       WebString::fromUTF8(session_id));
+  if (encrypted_client_)
+    encrypted_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) {
   EmeUMAHistogramEnumeration(current_key_system_, "KeyError",
                              error_code, MediaKeys::kMaxKeyError);
 
   uint16 short_system_code = 0;
   if (system_code > std::numeric_limits<uint16>::max()) {
     LOG(WARNING) << "system_code exceeds unsigned short limit.";
     short_system_code = std::numeric_limits<uint16>::max();
   } else {
     short_system_code = static_cast<uint16>(system_code);
   }
 
   client_->keyError(
       WebString::fromUTF8(GetPrefixedKeySystemName(current_key_system_)),
       WebString::fromUTF8(session_id),
       static_cast<WebMediaPlayerClient::MediaKeyErrorCode>(error_code),
       short_system_code);
+  if (encrypted_client_)
+    encrypted_client_->keyError(
+        WebString::fromUTF8(GetPrefixedKeySystemName(current_key_system_)),
+        WebString::fromUTF8(session_id),
+        static_cast<WebMediaPlayerEncryptedMediaClient::MediaKeyErrorCode>(
+            error_code),
+        short_system_code);
 }
 
 void EncryptedMediaPlayerSupport::OnKeyMessage(
     const std::string& session_id,
     const std::vector<uint8>& message,
     const GURL& destination_url) {
   DCHECK(destination_url.is_empty() || destination_url.is_valid());
 
   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);
+  if (encrypted_client_)
+    encrypted_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