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/render_process_host.h" |
| 12 #include "content/public/browser/storage_partition.h" |
| 13 #include "content/public/browser/web_contents.h" |
| 14 #include "content/public/common/content_client.h" |
| 15 |
| 16 // TODO(tguilbert): Remove this ID once MediaPlayerManager has been deleted |
| 17 // and MediaPlayerBridge updated. See comment in header file. |
| 18 const int kUnusedAndIrrelevantPlayerId = 0; |
| 19 |
| 20 namespace content { |
| 21 |
| 22 MediaPlayerRenderer::MediaPlayerRenderer(RenderFrameHost* render_frame_host) |
| 23 : render_frame_host_(render_frame_host), |
| 24 duration_(base::TimeDelta::FromMicroseconds(0)), |
| 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 LOG(ERROR) << "DemuxerStreamProvider is not of Type URL"; |
| 38 init_cb.Run(media::PIPELINE_ERROR_INITIALIZATION_FAILED); |
| 39 } |
| 40 |
| 41 GURL url = demuxer_stream_provider->GetUrl(); |
| 42 renderer_client_ = client; |
| 43 |
| 44 const std::string user_agent = GetContentClient()->GetUserAgent(); |
| 45 |
| 46 // TODO(tguilbert): FOR REVIEWERS: I am not sure what each parameter below |
| 47 // is used for. Are there any ones that I should be concerned with ATM? I |
| 48 // have added the parameter name for convenience next to the ones I don't |
| 49 // know what to do with. |
| 50 media_player_.reset(new media::MediaPlayerBridge( |
| 51 kUnusedAndIrrelevantPlayerId, url, |
| 52 GURL(), // first_party_for_cookies |
| 53 user_agent, |
| 54 false, // hide_url_log |
| 55 this, base::Bind(&MediaPlayerRenderer::OnDecoderResourcesReleased, |
| 56 weak_factory_.GetWeakPtr()), |
| 57 GURL(), // frame_url |
| 58 false, // allow_crendentials |
| 59 0)); // media_session_id |
| 60 |
| 61 // TODO(tguilbert): Register and Send the proper surface ID. See |
| 62 // crbug.com/627658 |
| 63 |
| 64 media_player_->Initialize(); |
| 65 init_cb.Run(media::PIPELINE_OK); |
| 66 } |
| 67 |
| 68 void MediaPlayerRenderer::SetCdm(media::CdmContext* cdm_context, |
| 69 const media::CdmAttachedCB& cdm_attached_cb) { |
| 70 NOTREACHED(); |
| 71 } |
| 72 |
| 73 void MediaPlayerRenderer::Flush(const base::Closure& flush_cb) { |
| 74 DVLOG(3) << __func__; |
| 75 flush_cb.Run(); |
| 76 } |
| 77 |
| 78 void MediaPlayerRenderer::StartPlayingFrom(base::TimeDelta time) { |
| 79 // MediaPlayerBridge's Start() is idempotent, except when it has encountered |
| 80 // an error (in which case, calling Start() again is logged as a new error). |
| 81 if (has_error_) |
| 82 return; |
| 83 |
| 84 media_player_->Start(); |
| 85 media_player_->SeekTo(time); |
| 86 } |
| 87 |
| 88 void MediaPlayerRenderer::SetPlaybackRate(double playback_rate) { |
| 89 if (has_error_) |
| 90 return; |
| 91 |
| 92 if (playback_rate == 0) { |
| 93 media_player_->Pause(true); |
| 94 } else { |
| 95 // MediaPlayerBridge's Start() is idempotent. |
| 96 media_player_->Start(); |
| 97 } |
| 98 } |
| 99 |
| 100 void MediaPlayerRenderer::SetVolume(float volume) { |
| 101 media_player_->SetVolume(volume); |
| 102 } |
| 103 |
| 104 base::TimeDelta MediaPlayerRenderer::GetMediaTime() { |
| 105 return media_player_->GetCurrentTime(); |
| 106 } |
| 107 |
| 108 bool MediaPlayerRenderer::HasAudio() { |
| 109 return media_player_->HasAudio(); |
| 110 } |
| 111 |
| 112 bool MediaPlayerRenderer::HasVideo() { |
| 113 return media_player_->HasVideo(); |
| 114 } |
| 115 |
| 116 media::MediaResourceGetter* MediaPlayerRenderer::GetMediaResourceGetter() { |
| 117 if (!media_resource_getter_.get()) { |
| 118 WebContents* web_contents = |
| 119 WebContents::FromRenderFrameHost(render_frame_host_); |
| 120 RenderProcessHost* host = web_contents->GetRenderProcessHost(); |
| 121 BrowserContext* context = host->GetBrowserContext(); |
| 122 StoragePartition* partition = host->GetStoragePartition(); |
| 123 storage::FileSystemContext* file_system_context = |
| 124 partition ? partition->GetFileSystemContext() : nullptr; |
| 125 // Eventually this needs to be fixed to pass the correct frame rather |
| 126 // than just using the main frame. |
| 127 media_resource_getter_.reset(new MediaResourceGetterImpl( |
| 128 context, file_system_context, host->GetID(), |
| 129 web_contents->GetMainFrame()->GetRoutingID())); |
| 130 } |
| 131 return media_resource_getter_.get(); |
| 132 } |
| 133 |
| 134 media::MediaUrlInterceptor* MediaPlayerRenderer::GetMediaUrlInterceptor() { |
| 135 return nullptr; |
| 136 } |
| 137 |
| 138 void MediaPlayerRenderer::OnTimeUpdate(int player_id, |
| 139 base::TimeDelta current_timestamp, |
| 140 base::TimeTicks current_time_ticks) {} |
| 141 |
| 142 void MediaPlayerRenderer::OnMediaMetadataChanged(int player_id, |
| 143 base::TimeDelta duration, |
| 144 int width, |
| 145 int height, |
| 146 bool success) { |
| 147 if (video_size_ != gfx::Size(width, height)) |
| 148 OnVideoSizeChanged(kUnusedAndIrrelevantPlayerId, width, height); |
| 149 |
| 150 if (duration_ != duration) { |
| 151 duration_ = duration; |
| 152 // TODO(tguilbert): Add OnDurationChange to the RendererClient interface. |
| 153 // See crbug.com/635991. |
| 154 } |
| 155 } |
| 156 |
| 157 void MediaPlayerRenderer::OnPlaybackComplete(int player_id) { |
| 158 renderer_client_->OnEnded(); |
| 159 } |
| 160 |
| 161 void MediaPlayerRenderer::OnMediaInterrupted(int player_id) {} |
| 162 |
| 163 void MediaPlayerRenderer::OnBufferingUpdate(int player_id, int percentage) { |
| 164 // As per Android documentation, |percentage| actually indicates "percentage |
| 165 // buffered or played". E.g. if we are at 50% playback and have 1% |
| 166 // buffered, |percentage| will be equal to 51. |
| 167 // |
| 168 // MediaPlayer manages its own buffering and will pause internally if ever it |
| 169 // runs out of data. Therefore, we can always return BUFFERING_HAVE_ENOUGH. |
| 170 renderer_client_->OnBufferingStateChange(media::BUFFERING_HAVE_ENOUGH); |
| 171 } |
| 172 |
| 173 void MediaPlayerRenderer::OnSeekComplete(int player_id, |
| 174 const base::TimeDelta& current_time) {} |
| 175 |
| 176 void MediaPlayerRenderer::OnError(int player_id, int error) { |
| 177 DVLOG(2) << __func__ << " Error: " << error; |
| 178 // TODO(tguilbert): Use more detailed errors if needed. |
| 179 |
| 180 // Some errors are forwarded to the MediaPlayerListener, but are of no |
| 181 // importance to us. Ignore these errors, which are reported as error 0 by |
| 182 // MediaPlayerListener. |
| 183 if (error) { |
| 184 has_error_ = true; |
| 185 renderer_client_->OnError(media::PIPELINE_ERROR_COULD_NOT_RENDER); |
| 186 } |
| 187 } |
| 188 |
| 189 void MediaPlayerRenderer::OnVideoSizeChanged(int player_id, |
| 190 int width, |
| 191 int height) { |
| 192 video_size_ = gfx::Size(width, height); |
| 193 renderer_client_->OnVideoNaturalSizeChange(video_size_); |
| 194 } |
| 195 |
| 196 void MediaPlayerRenderer::OnWaitingForDecryptionKey(int player_id) { |
| 197 NOTREACHED(); |
| 198 } |
| 199 |
| 200 media::MediaPlayerAndroid* MediaPlayerRenderer::GetFullscreenPlayer() { |
| 201 NOTREACHED(); |
| 202 return nullptr; |
| 203 } |
| 204 |
| 205 media::MediaPlayerAndroid* MediaPlayerRenderer::GetPlayer(int player_id) { |
| 206 NOTREACHED(); |
| 207 return nullptr; |
| 208 } |
| 209 |
| 210 bool MediaPlayerRenderer::RequestPlay(int player_id, |
| 211 base::TimeDelta duration, |
| 212 bool has_audio) { |
| 213 return true; |
| 214 } |
| 215 |
| 216 void MediaPlayerRenderer::OnDecoderResourcesReleased(int player_id) { |
| 217 // Since we are not using a pool of MediaPlayerAndroid instances, this |
| 218 // function is not relevant. |
| 219 |
| 220 // TODO(tguilbert): Investigate whether the use of the MediaThrottler is |
| 221 // needed. |
| 222 } |
| 223 |
| 224 } // namespace content |
OLD | NEW |