Eliminate MediaPlayer & MediaPlayerClient abstractions

content/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 "content/renderer/media/android/webmediaplayer_android.h"
 
 #include <limits>
 
 #include "base/android/build_info.h"
 #include "base/bind.h"
@@ skipping 130 matching lines @@
   blink::WebGraphicsContext3D* web_graphics_context_;
 };
 
 }  // namespace
 
 namespace content {
 
 WebMediaPlayerAndroid::WebMediaPlayerAndroid(
     blink::WebFrame* frame,
     blink::WebMediaPlayerClient* client,
+    blink::WebMediaPlayerEncryptedMediaClient* encrypted_client,
     base::WeakPtr<media::WebMediaPlayerDelegate> delegate,
     RendererMediaPlayerManager* player_manager,
     media::CdmFactory* cdm_factory,
     media::MediaPermission* media_permission,
     blink::WebContentDecryptionModule* initial_cdm,
     scoped_refptr<StreamTextureFactory> factory,
     const scoped_refptr<base::SingleThreadTaskRunner>& task_runner,
     media::MediaLog* media_log)
     : RenderFrameObserver(RenderFrame::FromWebFrame(frame)),
       frame_(frame),
       client_(client),
+      encrypted_client_(encrypted_client),
       delegate_(delegate),
       buffered_(static_cast<size_t>(1)),
       media_task_runner_(task_runner),
       ignore_metadata_duration_change_(false),
       pending_seek_(false),
       seeking_(false),
       did_loading_progress_(false),
       player_manager_(player_manager),
       cdm_factory_(cdm_factory),
       media_permission_(media_permission),
@@ skipping 637 matching lines @@
     player_manager_->Start(player_id_);
 }
 
 void WebMediaPlayerAndroid::OnBufferingUpdate(int percentage) {
   buffered_[0].end = duration() * percentage / 100;
   did_loading_progress_ = true;
 }
 
 void WebMediaPlayerAndroid::OnSeekRequest(const base::TimeDelta& time_to_seek) {
   DCHECK(main_thread_checker_.CalledOnValidThread());
-  client_->requestSeek(time_to_seek.InSecondsF());
+  client_->mediaPlayerRequestSeek(time_to_seek.InSecondsF());
 }
 
 void WebMediaPlayerAndroid::OnSeekComplete(
     const base::TimeDelta& current_time) {
   DCHECK(main_thread_checker_.CalledOnValidThread());
   seeking_ = false;
   if (pending_seek_) {
     pending_seek_ = false;
     seek(pending_seek_time_.InSecondsF());
     return;
@@ skipping 853 matching lines @@
 
   result.completeWithError(
       blink::WebContentDecryptionModuleExceptionNotSupportedError,
       0,
       "Unable to set MediaKeys object");
 }
 
 void WebMediaPlayerAndroid::OnKeyAdded(const std::string& session_id) {
   EmeUMAHistogramCounts(current_key_system_, "KeyAdded", 1);
 
-  client_->keyAdded(
+  encrypted_client_->keyAdded(
       WebString::fromUTF8(media::GetPrefixedKeySystemName(current_key_system_)),
       WebString::fromUTF8(session_id));
 }
 
 void WebMediaPlayerAndroid::OnKeyError(const std::string& session_id,
                                        media::MediaKeys::KeyError error_code,
                                        uint32 system_code) {
   EmeUMAHistogramEnumeration(current_key_system_, "KeyError",
                              error_code, media::MediaKeys::kMaxKeyError);
 
   unsigned short short_system_code = 0;
   if (system_code > std::numeric_limits<unsigned short>::max()) {
     LOG(WARNING) << "system_code exceeds unsigned short limit.";
     short_system_code = std::numeric_limits<unsigned short>::max();
   } else {
     short_system_code = static_cast<unsigned short>(system_code);
   }
 
-  client_->keyError(
+  encrypted_client_->keyError(
       WebString::fromUTF8(media::GetPrefixedKeySystemName(current_key_system_)),
       WebString::fromUTF8(session_id),
       static_cast<blink::WebMediaPlayerClient::MediaKeyErrorCode>(error_code),
       short_system_code);
 }
 
 void WebMediaPlayerAndroid::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(
+  encrypted_client_->keyMessage(
       WebString::fromUTF8(media::GetPrefixedKeySystemName(current_key_system_)),
-      WebString::fromUTF8(session_id),
-      message.empty() ? NULL : &message[0],
-      message.size(),
-      destination_url);
+      WebString::fromUTF8(session_id), message.empty() ? NULL : &message[0],
+      message.size(), destination_url);
 }
 
 void WebMediaPlayerAndroid::OnMediaSourceOpened(
     blink::WebMediaSource* web_media_source) {
   client_->mediaSourceOpened(web_media_source);
 }
 
 void WebMediaPlayerAndroid::OnEncryptedMediaInitData(
     media::EmeInitDataType init_data_type,
     const std::vector<uint8>& init_data) {
   DCHECK(main_thread_checker_.CalledOnValidThread());
 
   // 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 != media::EmeInitDataType::UNKNOWN);
   DLOG_IF(WARNING, init_data_type_ != media::EmeInitDataType::UNKNOWN &&
                        init_data_type != init_data_type_)
       << "Mixed init data type not supported. The new type is ignored.";
   if (init_data_type_ == media::EmeInitDataType::UNKNOWN)
     init_data_type_ = init_data_type;
 
-  client_->encrypted(ConvertToWebInitDataType(init_data_type),
-                     vector_as_array(&init_data), init_data.size());
+  encrypted_client_->encrypted(ConvertToWebInitDataType(init_data_type),
+                               vector_as_array(&init_data), init_data.size());
 }
 
 void WebMediaPlayerAndroid::OnWaitingForDecryptionKey() {
-  client_->didBlockPlaybackWaitingForKey();
+  encrypted_client_->didBlockPlaybackWaitingForKey();
 
   // TODO(jrummell): didResumePlaybackBlockedForKey() should only be called
   // when a key has been successfully added (e.g. OnSessionKeysChange() with
   // |has_additional_usable_key| = true). http://crbug.com/461903
-  client_->didResumePlaybackBlockedForKey();
+  encrypted_client_->didResumePlaybackBlockedForKey();
 }
 
 void WebMediaPlayerAndroid::OnCdmContextReady(media::CdmContext* cdm_context) {
   DCHECK(!cdm_context_);
 
   if (!cdm_context) {
     LOG(ERROR) << "CdmContext not available (e.g. CDM creation failed).";
     return;
   }
 
@@ skipping 80 matching lines @@
 
 bool WebMediaPlayerAndroid::IsHLSStream() const {
   std::string mime;
   GURL url = redirected_url_.is_empty() ? url_ : redirected_url_;
   if (!net::GetMimeTypeFromFile(base::FilePath(url.path()), &mime))
     return false;
   return !mime.compare("application/x-mpegurl");
 }
 
 }  // namespace content