OLD | NEW |
(Empty) | |
| 1 // Copyright 2016 The Chromium Authors. All rights reserved. |
| 2 // Use of this source code is governed by a BSD-style license that can be |
| 3 // found in the LICENSE file. |
| 4 |
| 5 #include "content/browser/media/android/media_player_renderer.h" |
| 6 |
| 7 #include <memory> |
| 8 |
| 9 #include "content/browser/media/android/media_resource_getter_impl.h" |
| 10 #include "content/public/browser/browser_context.h" |
| 11 #include "content/public/browser/browser_thread.h" |
| 12 #include "content/public/browser/render_process_host.h" |
| 13 #include "content/public/browser/storage_partition.h" |
| 14 #include "content/public/browser/web_contents.h" |
| 15 #include "content/public/common/content_client.h" |
| 16 |
| 17 // TODO(tguilbert): Remove this ID once MediaPlayerManager has been deleted |
| 18 // and MediaPlayerBridge updated. See comment in header file. |
| 19 constexpr int kUnusedAndIrrelevantPlayerId = 0; |
| 20 |
| 21 namespace content { |
| 22 |
| 23 MediaPlayerRenderer::MediaPlayerRenderer(RenderFrameHost* render_frame_host) |
| 24 : render_frame_host_(render_frame_host), |
| 25 has_error_(false), |
| 26 weak_factory_(this) {} |
| 27 |
| 28 MediaPlayerRenderer::~MediaPlayerRenderer() {} |
| 29 |
| 30 void MediaPlayerRenderer::Initialize( |
| 31 media::DemuxerStreamProvider* demuxer_stream_provider, |
| 32 media::RendererClient* client, |
| 33 const media::PipelineStatusCB& init_cb) { |
| 34 DVLOG(1) << __func__; |
| 35 if (demuxer_stream_provider->GetType() != |
| 36 media::DemuxerStreamProvider::Type::URL) { |
| 37 DLOG(ERROR) << "DemuxerStreamProvider is not of Type URL"; |
| 38 init_cb.Run(media::PIPELINE_ERROR_INITIALIZATION_FAILED); |
| 39 return; |
| 40 } |
| 41 |
| 42 GURL url = demuxer_stream_provider->GetUrl(); |
| 43 renderer_client_ = client; |
| 44 |
| 45 const std::string user_agent = GetContentClient()->GetUserAgent(); |
| 46 |
| 47 // TODO(tguilbert): Get the first party cookies from WMPI. See |
| 48 // crbug.com/636604. |
| 49 media_player_.reset(new media::MediaPlayerBridge( |
| 50 kUnusedAndIrrelevantPlayerId, url, |
| 51 GURL(), // first_party_for_cookies |
| 52 user_agent, |
| 53 false, // hide_url_log |
| 54 this, base::Bind(&MediaPlayerRenderer::OnDecoderResourcesReleased, |
| 55 weak_factory_.GetWeakPtr()), |
| 56 GURL(), // frame_url |
| 57 false, // allow_crendentials |
| 58 0)); // media_session_id |
| 59 |
| 60 // TODO(tguilbert): Register and Send the proper surface ID. See |
| 61 // crbug.com/627658 |
| 62 |
| 63 media_player_->Initialize(); |
| 64 init_cb.Run(media::PIPELINE_OK); |
| 65 } |
| 66 |
| 67 void MediaPlayerRenderer::SetCdm(media::CdmContext* cdm_context, |
| 68 const media::CdmAttachedCB& cdm_attached_cb) { |
| 69 NOTREACHED(); |
| 70 } |
| 71 |
| 72 void MediaPlayerRenderer::Flush(const base::Closure& flush_cb) { |
| 73 DVLOG(3) << __func__; |
| 74 flush_cb.Run(); |
| 75 } |
| 76 |
| 77 void MediaPlayerRenderer::StartPlayingFrom(base::TimeDelta time) { |
| 78 // MediaPlayerBridge's Start() is idempotent, except when it has encountered |
| 79 // an error (in which case, calling Start() again is logged as a new error). |
| 80 if (has_error_) |
| 81 return; |
| 82 |
| 83 media_player_->Start(); |
| 84 media_player_->SeekTo(time); |
| 85 } |
| 86 |
| 87 void MediaPlayerRenderer::SetPlaybackRate(double playback_rate) { |
| 88 if (has_error_) |
| 89 return; |
| 90 |
| 91 if (playback_rate == 0) { |
| 92 media_player_->Pause(true); |
| 93 } else { |
| 94 // MediaPlayerBridge's Start() is idempotent. |
| 95 media_player_->Start(); |
| 96 |
| 97 // TODO(tguilbert): MediaPlayer's interface allows variable playback rate, |
| 98 // but is not currently exposed in the MediaPlayerBridge interface. |
| 99 // Investigate wether or not we want to add variable playback speed. |
| 100 } |
| 101 } |
| 102 |
| 103 void MediaPlayerRenderer::SetVolume(float volume) { |
| 104 media_player_->SetVolume(volume); |
| 105 } |
| 106 |
| 107 base::TimeDelta MediaPlayerRenderer::GetMediaTime() { |
| 108 return media_player_->GetCurrentTime(); |
| 109 } |
| 110 |
| 111 bool MediaPlayerRenderer::HasAudio() { |
| 112 return media_player_->HasAudio(); |
| 113 } |
| 114 |
| 115 bool MediaPlayerRenderer::HasVideo() { |
| 116 return media_player_->HasVideo(); |
| 117 } |
| 118 |
| 119 media::MediaResourceGetter* MediaPlayerRenderer::GetMediaResourceGetter() { |
| 120 DCHECK_CURRENTLY_ON(BrowserThread::UI); |
| 121 if (!media_resource_getter_.get()) { |
| 122 WebContents* web_contents = |
| 123 WebContents::FromRenderFrameHost(render_frame_host_); |
| 124 RenderProcessHost* host = web_contents->GetRenderProcessHost(); |
| 125 BrowserContext* context = host->GetBrowserContext(); |
| 126 StoragePartition* partition = host->GetStoragePartition(); |
| 127 storage::FileSystemContext* file_system_context = |
| 128 partition ? partition->GetFileSystemContext() : nullptr; |
| 129 media_resource_getter_.reset( |
| 130 new MediaResourceGetterImpl(context, file_system_context, host->GetID(), |
| 131 render_frame_host_->GetRoutingID())); |
| 132 } |
| 133 return media_resource_getter_.get(); |
| 134 } |
| 135 |
| 136 media::MediaUrlInterceptor* MediaPlayerRenderer::GetMediaUrlInterceptor() { |
| 137 // TODO(tguilbert): Offer a RegisterMediaUrlInterceptor equivalent for use in |
| 138 // webview. See crbug.com/636588. |
| 139 return nullptr; |
| 140 } |
| 141 |
| 142 void MediaPlayerRenderer::OnTimeUpdate(int player_id, |
| 143 base::TimeDelta current_timestamp, |
| 144 base::TimeTicks current_time_ticks) {} |
| 145 |
| 146 void MediaPlayerRenderer::OnMediaMetadataChanged(int player_id, |
| 147 base::TimeDelta duration, |
| 148 int width, |
| 149 int height, |
| 150 bool success) { |
| 151 if (video_size_ != gfx::Size(width, height)) |
| 152 OnVideoSizeChanged(kUnusedAndIrrelevantPlayerId, width, height); |
| 153 |
| 154 if (duration_ != duration) { |
| 155 duration_ = duration; |
| 156 // TODO(tguilbert): Add OnDurationChange to the RendererClient interface. |
| 157 // See crbug.com/635991. |
| 158 } |
| 159 } |
| 160 |
| 161 void MediaPlayerRenderer::OnPlaybackComplete(int player_id) { |
| 162 renderer_client_->OnEnded(); |
| 163 } |
| 164 |
| 165 void MediaPlayerRenderer::OnMediaInterrupted(int player_id) {} |
| 166 |
| 167 void MediaPlayerRenderer::OnBufferingUpdate(int player_id, int percentage) { |
| 168 // As per Android documentation, |percentage| actually indicates "percentage |
| 169 // buffered or played". E.g. if we are at 50% playback and have 1% |
| 170 // buffered, |percentage| will be equal to 51. |
| 171 // |
| 172 // MediaPlayer manages its own buffering and will pause internally if ever it |
| 173 // runs out of data. Therefore, we can always return BUFFERING_HAVE_ENOUGH. |
| 174 renderer_client_->OnBufferingStateChange(media::BUFFERING_HAVE_ENOUGH); |
| 175 } |
| 176 |
| 177 void MediaPlayerRenderer::OnSeekComplete(int player_id, |
| 178 const base::TimeDelta& current_time) {} |
| 179 |
| 180 void MediaPlayerRenderer::OnError(int player_id, int error) { |
| 181 // Some errors are forwarded to the MediaPlayerListener, but are of no |
| 182 // importance to us. Ignore these errors, which are reported as error 0 by |
| 183 // MediaPlayerListener. |
| 184 if (!error) |
| 185 return; |
| 186 |
| 187 LOG(ERROR) << __func__ << " Error: " << error; |
| 188 has_error_ = true; |
| 189 renderer_client_->OnError(media::PIPELINE_ERROR_EXTERNAL_RENDERER_FAILED); |
| 190 } |
| 191 |
| 192 void MediaPlayerRenderer::OnVideoSizeChanged(int player_id, |
| 193 int width, |
| 194 int height) { |
| 195 video_size_ = gfx::Size(width, height); |
| 196 renderer_client_->OnVideoNaturalSizeChange(video_size_); |
| 197 } |
| 198 |
| 199 void MediaPlayerRenderer::OnWaitingForDecryptionKey(int player_id) { |
| 200 NOTREACHED(); |
| 201 } |
| 202 |
| 203 media::MediaPlayerAndroid* MediaPlayerRenderer::GetFullscreenPlayer() { |
| 204 NOTREACHED(); |
| 205 return nullptr; |
| 206 } |
| 207 |
| 208 media::MediaPlayerAndroid* MediaPlayerRenderer::GetPlayer(int player_id) { |
| 209 NOTREACHED(); |
| 210 return nullptr; |
| 211 } |
| 212 |
| 213 bool MediaPlayerRenderer::RequestPlay(int player_id, |
| 214 base::TimeDelta duration, |
| 215 bool has_audio) { |
| 216 // TODO(tguilbert): Throttle requests, via exponential backoff. |
| 217 // See crbug.com/636615. |
| 218 return true; |
| 219 } |
| 220 |
| 221 void MediaPlayerRenderer::OnDecoderResourcesReleased(int player_id) { |
| 222 // Since we are not using a pool of MediaPlayerAndroid instances, this |
| 223 // function is not relevant. |
| 224 |
| 225 // TODO(tguilbert): Throttle requests, via exponential backoff. |
| 226 // See crbug.com/636615. |
| 227 } |
| 228 |
| 229 } // namespace content |
OLD | NEW |