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