Rename MediaPlayerBridgeManager to MediaPlayerManager

media/base/android/media_player_bridge.cc

 // Copyright (c) 2012 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/base/android/media_player_bridge.h"
 
 #include "base/android/jni_android.h"
 #include "base/android/jni_string.h"
 #include "base/basictypes.h"
 #include "base/logging.h"
 #include "base/message_loop_proxy.h"
 #include "jni/MediaPlayerBridge_jni.h"
 #include "jni/MediaPlayer_jni.h"
-#include "media/base/android/media_player_bridge_manager.h"
+#include "media/base/android/media_player_manager.h"
 #include "media/base/android/media_resource_getter.h"
 
 using base::android::ConvertUTF8ToJavaString;
 using base::android::ScopedJavaLocalRef;
 
 // Time update happens every 250ms.
 static const int kTimeUpdateInterval = 250;
 
 // Android MediaMetadataRetriever may fail to extract the metadata from the
 // media under some circumstances. This makes the user unable to perform
 // seek. To solve this problem, we use a temporary duration of 100 seconds when
 // the duration is unknown. And we scale the seek position later when duration
 // is available.
 static const int kTemporaryDuration = 100;
 
 namespace media {
 
 #if !defined(GOOGLE_TV)
 // static
 MediaPlayerBridge* MediaPlayerBridge::Create(
     int player_id,
     const GURL& url,
     bool is_media_source,
     const GURL& first_party_for_cookies,
-    MediaResourceGetter* resource_getter,
     bool hide_url_log,
-    MediaPlayerBridgeManager* manager,
+    MediaPlayerManager* manager,
     const MediaErrorCB& media_error_cb,
     const VideoSizeChangedCB& video_size_changed_cb,
     const BufferingUpdateCB& buffering_update_cb,
     const MediaMetadataChangedCB& media_prepared_cb,
     const PlaybackCompleteCB& playback_complete_cb,
     const SeekCompleteCB& seek_complete_cb,
     const TimeUpdateCB& time_update_cb,
     const MediaInterruptedCB& media_interrupted_cb) {
   LOG_IF(WARNING, is_media_source) << "MSE is not supported";
   return new MediaPlayerBridge(
       player_id,
       url,
       first_party_for_cookies,
-      resource_getter,
       hide_url_log,
       manager,
       media_error_cb,
       video_size_changed_cb,
       buffering_update_cb,
       media_prepared_cb,
       playback_complete_cb,
       seek_complete_cb,
       time_update_cb,
       media_interrupted_cb);
 }
 #endif
 
 MediaPlayerBridge::MediaPlayerBridge(
     int player_id,
     const GURL& url,
     const GURL& first_party_for_cookies,
-    MediaResourceGetter* resource_getter,
     bool hide_url_log,
-    MediaPlayerBridgeManager* manager,
+    MediaPlayerManager* manager,
     const MediaErrorCB& media_error_cb,
     const VideoSizeChangedCB& video_size_changed_cb,
     const BufferingUpdateCB& buffering_update_cb,
     const MediaMetadataChangedCB& media_metadata_changed_cb,
     const PlaybackCompleteCB& playback_complete_cb,
     const SeekCompleteCB& seek_complete_cb,
     const TimeUpdateCB& time_update_cb,
     const MediaInterruptedCB& media_interrupted_cb)
     : media_error_cb_(media_error_cb),
       video_size_changed_cb_(video_size_changed_cb),
       buffering_update_cb_(buffering_update_cb),
       media_metadata_changed_cb_(media_metadata_changed_cb),
       playback_complete_cb_(playback_complete_cb),
       seek_complete_cb_(seek_complete_cb),
       media_interrupted_cb_(media_interrupted_cb),
       time_update_cb_(time_update_cb),
       player_id_(player_id),
       prepared_(false),
       pending_play_(false),
       url_(url),
       first_party_for_cookies_(first_party_for_cookies),
       hide_url_log_(hide_url_log),
       duration_(base::TimeDelta::FromSeconds(kTemporaryDuration)),
       width_(0),
       height_(0),
       can_pause_(true),
       can_seek_forward_(true),
       can_seek_backward_(true),
       manager_(manager),
-      resource_getter_(resource_getter),
       weak_this_(this),
       listener_(base::MessageLoopProxy::current(),
                 weak_this_.GetWeakPtr()) {
   Initialize();
 }
 
 MediaPlayerBridge::~MediaPlayerBridge() {
   Release();
 }
 
 void MediaPlayerBridge::Initialize() {
   if (url_.SchemeIsFile()) {
     cookies_.clear();
     ExtractMediaMetadata(url_.spec());
     return;
   }
 
+  media::MediaResourceGetter* resource_getter =
+      manager_->GetMediaResourceGetter();
+
   if (url_.SchemeIsFileSystem()) {
     cookies_.clear();
-    resource_getter_->GetPlatformPathFromFileSystemURL(url_, base::Bind(
+    resource_getter->GetPlatformPathFromFileSystemURL(url_, base::Bind(
         &MediaPlayerBridge::ExtractMediaMetadata, weak_this_.GetWeakPtr()));
     return;
   }
 
-  resource_getter_->GetCookies(url_, first_party_for_cookies_, base::Bind(
+  resource_getter->GetCookies(url_, first_party_for_cookies_, base::Bind(
       &MediaPlayerBridge::OnCookiesRetrieved, weak_this_.GetWeakPtr()));
 }
 
 void MediaPlayerBridge::CreateMediaPlayer() {
   JNIEnv* env = base::android::AttachCurrentThread();
   CHECK(env);
 
   j_media_player_.Reset(JNI_MediaPlayer::Java_MediaPlayer_Constructor(env));
 
   SetMediaPlayerListener();
@@ skipping 24 matching lines @@
   CHECK(env);
 
   JNI_MediaPlayer::Java_MediaPlayer_setSurface(
       env, j_media_player_.obj(), surface);
 }
 
 void MediaPlayerBridge::Prepare() {
   if (j_media_player_.is_null())
     CreateMediaPlayer();
   if (url_.SchemeIsFileSystem()) {
-    resource_getter_->GetPlatformPathFromFileSystemURL(url_, base::Bind(
-        &MediaPlayerBridge::SetDataSource, weak_this_.GetWeakPtr()));
+    manager_->GetMediaResourceGetter()->GetPlatformPathFromFileSystemURL(
+        url_, base::Bind(&MediaPlayerBridge::SetDataSource,
+                         weak_this_.GetWeakPtr()));
   } else {
     SetDataSource(url_.spec());
   }
 }
 
 void MediaPlayerBridge::SetDataSource(const std::string& url) {
   if (j_media_player_.is_null())
     return;
 
   JNIEnv* env = base::android::AttachCurrentThread();
@@ skipping 17 matching lines @@
     media_error_cb_.Run(player_id_, MEDIA_ERROR_FORMAT);
   }
 }
 
 void MediaPlayerBridge::OnCookiesRetrieved(const std::string& cookies) {
   cookies_ = cookies;
   ExtractMediaMetadata(url_.spec());
 }
 
 void MediaPlayerBridge::ExtractMediaMetadata(const std::string& url) {
-  resource_getter_->ExtractMediaMetadata(
+  manager_->GetMediaResourceGetter()->ExtractMediaMetadata(
       url, cookies_, base::Bind(&MediaPlayerBridge::OnMediaMetadataExtracted,
                                 weak_this_.GetWeakPtr()));
 }
 
 void MediaPlayerBridge::OnMediaMetadataExtracted(
     base::TimeDelta duration, int width, int height, bool success) {
   if (success) {
     duration_ = duration;
     width_ = width;
     height_ = height;
@@ skipping 234 matching lines @@
   NOTREACHED() << "Unexpected ipc received";
 }
 
 void MediaPlayerBridge::ReadFromDemuxerAck(
     const MediaPlayerHostMsg_ReadFromDemuxerAck_Params& params) {
   NOTREACHED() << "Unexpected ipc received";
 }
 #endif
 
 }  // namespace media