EME v0.1: Report defaultURL in KeyMessage.
[WebKit-https.git] / Source / WebKit / chromium / src / WebMediaPlayerClientImpl.cpp
1 // Copyright (c) 2009 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 "config.h"
6 #include "WebMediaPlayerClientImpl.h"
7
8 #if ENABLE(VIDEO)
9
10 #include "AudioBus.h"
11 #include "AudioSourceProvider.h"
12 #include "AudioSourceProviderClient.h"
13 #include "Frame.h"
14 #include "GraphicsContext.h"
15 #include "GraphicsLayerChromium.h"
16 #include "HTMLMediaElement.h"
17 #include "IntSize.h"
18 #include "KURL.h"
19 #include "MediaPlayer.h"
20 #include "NotImplemented.h"
21 #include "PlatformContextSkia.h"
22 #include "RenderView.h"
23 #include "TimeRanges.h"
24 #include "WebAudioSourceProvider.h"
25 #include "WebFrameClient.h"
26 #include "WebFrameImpl.h"
27 #include "WebHelperPluginImpl.h"
28 #include "WebMediaPlayer.h"
29 #include "WebViewImpl.h"
30 #include <public/Platform.h>
31 #include <public/WebCString.h>
32 #include <public/WebCanvas.h>
33 #include <public/WebCompositorSupport.h>
34 #include <public/WebMimeRegistry.h>
35 #include <public/WebRect.h>
36 #include <public/WebSize.h>
37 #include <public/WebString.h>
38 #include <public/WebURL.h>
39 #include <public/WebVideoLayer.h>
40
41 #if USE(ACCELERATED_COMPOSITING)
42 #include "RenderLayerCompositor.h"
43 #endif
44
45 #include <wtf/Assertions.h>
46 #include <wtf/text/CString.h>
47
48 using namespace WebCore;
49
50 namespace WebKit {
51
52 static PassOwnPtr<WebMediaPlayer> createWebMediaPlayer(WebMediaPlayerClient* client, const WebURL& url, Frame* frame)
53 {
54     WebFrameImpl* webFrame = WebFrameImpl::fromFrame(frame);
55
56     if (!webFrame->client())
57         return nullptr;
58     return adoptPtr(webFrame->client()->createMediaPlayer(webFrame, url, client));
59 }
60
61 bool WebMediaPlayerClientImpl::m_isEnabled = false;
62
63 bool WebMediaPlayerClientImpl::isEnabled()
64 {
65     return m_isEnabled;
66 }
67
68 void WebMediaPlayerClientImpl::setIsEnabled(bool isEnabled)
69 {
70     m_isEnabled = isEnabled;
71 }
72
73 void WebMediaPlayerClientImpl::registerSelf(MediaEngineRegistrar registrar)
74 {
75     if (m_isEnabled) {
76         registrar(WebMediaPlayerClientImpl::create,
77                   WebMediaPlayerClientImpl::getSupportedTypes,
78                   WebMediaPlayerClientImpl::supportsType,
79                   0,
80                   0,
81                   0);
82     }
83 }
84
85 WebMediaPlayer* WebMediaPlayerClientImpl::mediaPlayer() const
86 {
87     return m_webMediaPlayer.get();
88 }
89
90 // WebMediaPlayerClient --------------------------------------------------------
91
92 WebMediaPlayerClientImpl::~WebMediaPlayerClientImpl()
93 {
94 #if USE(ACCELERATED_COMPOSITING)
95     if (m_videoFrameProviderClient)
96         m_videoFrameProviderClient->stopUsingProvider();
97     // No need for a lock here, as getCurrentFrame/putCurrentFrame can't be
98     // called now that the client is no longer using this provider. Also, load()
99     // and this destructor are called from the same thread.
100     if (m_webMediaPlayer)
101         m_webMediaPlayer->setStreamTextureClient(0);
102 #endif
103     if (m_helperPlugin)
104         closeHelperPlugin();
105 #if USE(ACCELERATED_COMPOSITING)
106     if (m_videoLayer)
107         GraphicsLayerChromium::unregisterContentsLayer(m_videoLayer->layer());
108 #endif
109 }
110
111 void WebMediaPlayerClientImpl::networkStateChanged()
112 {
113     ASSERT(m_mediaPlayer);
114     m_mediaPlayer->networkStateChanged();
115 }
116
117 void WebMediaPlayerClientImpl::readyStateChanged()
118 {
119     ASSERT(m_mediaPlayer);
120     m_mediaPlayer->readyStateChanged();
121 #if USE(ACCELERATED_COMPOSITING)
122     if (hasVideo() && supportsAcceleratedRendering() && !m_videoLayer) {
123         m_videoLayer = adoptPtr(Platform::current()->compositorSupport()->createVideoLayer(this));
124
125         m_videoLayer->layer()->setOpaque(m_opaque);
126         GraphicsLayerChromium::registerContentsLayer(m_videoLayer->layer());
127     }
128 #endif
129 }
130
131 void WebMediaPlayerClientImpl::volumeChanged(float newVolume)
132 {
133     ASSERT(m_mediaPlayer);
134     m_mediaPlayer->volumeChanged(newVolume);
135 }
136
137 void WebMediaPlayerClientImpl::muteChanged(bool newMute)
138 {
139     ASSERT(m_mediaPlayer);
140     m_mediaPlayer->muteChanged(newMute);
141 }
142
143 void WebMediaPlayerClientImpl::timeChanged()
144 {
145     ASSERT(m_mediaPlayer);
146     m_mediaPlayer->timeChanged();
147 }
148
149 void WebMediaPlayerClientImpl::repaint()
150 {
151     ASSERT(m_mediaPlayer);
152 #if USE(ACCELERATED_COMPOSITING)
153     if (m_videoLayer && supportsAcceleratedRendering())
154         m_videoLayer->layer()->invalidate();
155 #endif
156     m_mediaPlayer->repaint();
157 }
158
159 void WebMediaPlayerClientImpl::durationChanged()
160 {
161     ASSERT(m_mediaPlayer);
162     m_mediaPlayer->durationChanged();
163 }
164
165 void WebMediaPlayerClientImpl::rateChanged()
166 {
167     ASSERT(m_mediaPlayer);
168     m_mediaPlayer->rateChanged();
169 }
170
171 void WebMediaPlayerClientImpl::sizeChanged()
172 {
173     ASSERT(m_mediaPlayer);
174     m_mediaPlayer->sizeChanged();
175 }
176
177 void WebMediaPlayerClientImpl::setOpaque(bool opaque)
178 {
179 #if USE(ACCELERATED_COMPOSITING)
180     m_opaque = opaque;
181     if (m_videoLayer)
182         m_videoLayer->layer()->setOpaque(m_opaque);
183 #endif
184 }
185
186 void WebMediaPlayerClientImpl::sawUnsupportedTracks()
187 {
188     ASSERT(m_mediaPlayer);
189     m_mediaPlayer->mediaPlayerClient()->mediaPlayerSawUnsupportedTracks(m_mediaPlayer);
190 }
191
192 float WebMediaPlayerClientImpl::volume() const
193 {
194     if (m_mediaPlayer)
195         return m_mediaPlayer->volume();
196     return 0.0f;
197 }
198
199 void WebMediaPlayerClientImpl::playbackStateChanged()
200 {
201     ASSERT(m_mediaPlayer);
202     m_mediaPlayer->playbackStateChanged();
203 }
204
205 WebMediaPlayer::Preload WebMediaPlayerClientImpl::preload() const
206 {
207     if (m_mediaPlayer)
208         return static_cast<WebMediaPlayer::Preload>(m_mediaPlayer->preload());
209     return static_cast<WebMediaPlayer::Preload>(m_preload);
210 }
211
212 void WebMediaPlayerClientImpl::sourceOpened()
213 {
214 #if ENABLE(MEDIA_SOURCE)
215     ASSERT(m_mediaPlayer);
216     m_mediaPlayer->sourceOpened();
217 #endif
218 }
219
220 WebKit::WebURL WebMediaPlayerClientImpl::sourceURL() const
221 {
222 #if ENABLE(MEDIA_SOURCE)
223     ASSERT(m_mediaPlayer);
224     return KURL(ParsedURLString, m_mediaPlayer->sourceURL());
225 #else
226     return KURL();
227 #endif
228 }
229
230 void WebMediaPlayerClientImpl::keyAdded(const WebString& keySystem, const WebString& sessionId)
231 {
232 #if ENABLE(ENCRYPTED_MEDIA)
233     ASSERT(m_mediaPlayer);
234     m_mediaPlayer->keyAdded(keySystem, sessionId);
235 #else
236     UNUSED_PARAM(keySystem);
237     UNUSED_PARAM(sessionId);
238 #endif
239 }
240
241 void WebMediaPlayerClientImpl::keyError(const WebString& keySystem, const WebString& sessionId, MediaKeyErrorCode errorCode, unsigned short systemCode)
242 {
243 #if ENABLE(ENCRYPTED_MEDIA)
244     ASSERT(m_mediaPlayer);
245     m_mediaPlayer->keyError(keySystem, sessionId, static_cast<MediaPlayerClient::MediaKeyErrorCode>(errorCode), systemCode);
246 #else
247     UNUSED_PARAM(keySystem);
248     UNUSED_PARAM(sessionId);
249     UNUSED_PARAM(errorCode);
250     UNUSED_PARAM(systemCode);
251 #endif
252 }
253
254 void WebMediaPlayerClientImpl::keyMessage(const WebString& keySystem, const WebString& sessionId, const unsigned char* message, unsigned messageLength, const WebURL& defaultURL)
255 {
256 #if ENABLE(ENCRYPTED_MEDIA)
257     ASSERT(m_mediaPlayer);
258     m_mediaPlayer->keyMessage(keySystem, sessionId, message, messageLength, defaultURL);
259 #else
260     UNUSED_PARAM(keySystem);
261     UNUSED_PARAM(sessionId);
262     UNUSED_PARAM(message);
263     UNUSED_PARAM(messageLength);
264     UNUSED_PARAM(defaultURL);
265 #endif
266 }
267
268 // FIXME(ddorwin): Remove after rolling WebKit in Chromium and Chromium is updated to use the new signature.
269 void WebMediaPlayerClient::keyMessage(const WebString& keySystem, const WebString& sessionId, const unsigned char* message, unsigned messageLength)
270 {
271     keyMessage(keySystem, sessionId, message, messageLength, WebURL());
272 }
273
274 void WebMediaPlayerClientImpl::keyNeeded(const WebString& keySystem, const WebString& sessionId, const unsigned char* initData, unsigned initDataLength)
275 {
276 #if ENABLE(ENCRYPTED_MEDIA)
277     ASSERT(m_mediaPlayer);
278     m_mediaPlayer->keyNeeded(keySystem, sessionId, initData, initDataLength);
279 #else
280     UNUSED_PARAM(keySystem);
281     UNUSED_PARAM(sessionId);
282     UNUSED_PARAM(initData);
283     UNUSED_PARAM(initDataLength);
284 #endif
285 }
286
287 WebPlugin* WebMediaPlayerClientImpl::createHelperPlugin(const WebString& pluginType, WebFrame* frame)
288 {
289     ASSERT(!m_helperPlugin);
290     WebViewImpl* webView = static_cast<WebViewImpl*>(frame->view());
291     m_helperPlugin = webView->createHelperPlugin(pluginType);
292     if (!m_helperPlugin)
293         return 0;
294
295     WebPlugin* plugin = m_helperPlugin->getPlugin();
296     if (!plugin) {
297         // There is no need to keep the helper plugin around and the caller
298         // should not be expected to call close after a failure (null pointer).
299         closeHelperPlugin();
300         return 0;
301     }
302
303     return plugin;
304 }
305
306 void WebMediaPlayerClientImpl::closeHelperPlugin()
307 {
308     ASSERT(m_helperPlugin);
309     m_helperPlugin->closeHelperPlugin();
310     m_helperPlugin = 0;
311 }
312
313 void WebMediaPlayerClientImpl::disableAcceleratedCompositing()
314 {
315     m_supportsAcceleratedCompositing = false;
316 }
317
318 // MediaPlayerPrivateInterface -------------------------------------------------
319
320 void WebMediaPlayerClientImpl::load(const String& url)
321 {
322     m_url = url;
323
324     MutexLocker locker(m_webMediaPlayerMutex);
325     if (m_preload == MediaPlayer::None) {
326 #if ENABLE(WEB_AUDIO)
327         m_audioSourceProvider.wrap(0); // Clear weak reference to m_webMediaPlayer's WebAudioSourceProvider.
328 #endif
329         m_webMediaPlayer.clear();
330         m_delayingLoad = true;
331     } else
332         loadInternal();
333 }
334
335 void WebMediaPlayerClientImpl::loadInternal()
336 {
337 #if ENABLE(WEB_AUDIO)
338     m_audioSourceProvider.wrap(0); // Clear weak reference to m_webMediaPlayer's WebAudioSourceProvider.
339 #endif
340
341     Frame* frame = static_cast<HTMLMediaElement*>(m_mediaPlayer->mediaPlayerClient())->document()->frame();
342     m_webMediaPlayer = createWebMediaPlayer(this, KURL(ParsedURLString, m_url), frame);
343     if (m_webMediaPlayer) {
344 #if ENABLE(WEB_AUDIO)
345         // Make sure if we create/re-create the WebMediaPlayer that we update our wrapper.
346         m_audioSourceProvider.wrap(m_webMediaPlayer->audioSourceProvider());
347 #endif
348         m_webMediaPlayer->load(
349             KURL(ParsedURLString, m_url),
350             static_cast<WebMediaPlayer::CORSMode>(m_mediaPlayer->mediaPlayerClient()->mediaPlayerCORSMode()));
351     }
352 }
353
354 void WebMediaPlayerClientImpl::cancelLoad()
355 {
356     if (m_webMediaPlayer)
357         m_webMediaPlayer->cancelLoad();
358 }
359
360 #if USE(ACCELERATED_COMPOSITING)
361 WebLayer* WebMediaPlayerClientImpl::platformLayer() const
362 {
363     ASSERT(m_supportsAcceleratedCompositing);
364     return m_videoLayer ? m_videoLayer->layer() : 0;
365 }
366 #endif
367
368 PlatformMedia WebMediaPlayerClientImpl::platformMedia() const
369 {
370     PlatformMedia pm;
371     pm.type = PlatformMedia::ChromiumMediaPlayerType;
372     pm.media.chromiumMediaPlayer = const_cast<WebMediaPlayerClientImpl*>(this);
373     return pm;
374 }
375
376 void WebMediaPlayerClientImpl::play()
377 {
378     if (m_webMediaPlayer)
379         m_webMediaPlayer->play();
380 }
381
382 void WebMediaPlayerClientImpl::pause()
383 {
384     if (m_webMediaPlayer)
385         m_webMediaPlayer->pause();
386 }
387
388 #if USE(NATIVE_FULLSCREEN_VIDEO)
389 void WebMediaPlayerClientImpl::enterFullscreen()
390 {
391     if (m_webMediaPlayer)
392         m_webMediaPlayer->enterFullscreen();
393 }
394
395 void WebMediaPlayerClientImpl::exitFullscreen()
396 {
397     if (m_webMediaPlayer)
398         m_webMediaPlayer->exitFullscreen();
399 }
400
401 bool WebMediaPlayerClientImpl::canEnterFullscreen() const
402 {
403     return m_webMediaPlayer && m_webMediaPlayer->canEnterFullscreen();
404 }
405 #endif
406
407 #if ENABLE(MEDIA_SOURCE)
408 WebCore::MediaPlayer::AddIdStatus WebMediaPlayerClientImpl::sourceAddId(const String& id, const String& type, const Vector<String>& codecs)
409 {
410     if (!m_webMediaPlayer)
411         return WebCore::MediaPlayer::NotSupported;
412
413     return static_cast<WebCore::MediaPlayer::AddIdStatus>(m_webMediaPlayer->sourceAddId(id, type, codecs));
414 }
415
416 bool WebMediaPlayerClientImpl::sourceRemoveId(const String& id)
417 {
418     if (!m_webMediaPlayer)
419         return false;
420
421     return m_webMediaPlayer->sourceRemoveId(id);
422 }
423
424 PassRefPtr<TimeRanges> WebMediaPlayerClientImpl::sourceBuffered(const String& id)
425 {
426     if (!m_webMediaPlayer)
427         return TimeRanges::create();
428
429     WebTimeRanges webRanges = m_webMediaPlayer->sourceBuffered(id);
430     RefPtr<TimeRanges> ranges = TimeRanges::create();
431     for (size_t i = 0; i < webRanges.size(); ++i)
432         ranges->add(webRanges[i].start, webRanges[i].end);
433     return ranges.release();
434 }
435
436 bool WebMediaPlayerClientImpl::sourceAppend(const String& id, const unsigned char* data, unsigned length)
437 {
438     if (m_webMediaPlayer)
439         return m_webMediaPlayer->sourceAppend(id, data, length);
440     return false;
441 }
442
443 bool WebMediaPlayerClientImpl::sourceAbort(const String& id)
444 {
445     if (!m_webMediaPlayer)
446         return false;
447
448     return m_webMediaPlayer->sourceAbort(id);
449 }
450
451 void WebMediaPlayerClientImpl::sourceSetDuration(double duration)
452 {
453     if (m_webMediaPlayer)
454         m_webMediaPlayer->sourceSetDuration(duration);
455 }
456
457 void WebMediaPlayerClientImpl::sourceEndOfStream(WebCore::MediaPlayer::EndOfStreamStatus status)
458 {
459     if (m_webMediaPlayer)
460         m_webMediaPlayer->sourceEndOfStream(static_cast<WebMediaPlayer::EndOfStreamStatus>(status));
461 }
462
463 bool WebMediaPlayerClientImpl::sourceSetTimestampOffset(const String& id, double offset)
464 {
465     if (!m_webMediaPlayer)
466         return false;
467     return m_webMediaPlayer->sourceSetTimestampOffset(id, offset);
468 }
469 #endif
470
471 #if ENABLE(ENCRYPTED_MEDIA)
472 MediaPlayer::MediaKeyException WebMediaPlayerClientImpl::generateKeyRequest(const String& keySystem, const unsigned char* initData, unsigned initDataLength)
473 {
474     if (!m_webMediaPlayer)
475         return MediaPlayer::InvalidPlayerState;
476
477     WebMediaPlayer::MediaKeyException result = m_webMediaPlayer->generateKeyRequest(keySystem, initData, initDataLength);
478     return static_cast<MediaPlayer::MediaKeyException>(result);
479 }
480
481 MediaPlayer::MediaKeyException WebMediaPlayerClientImpl::addKey(const String& keySystem, const unsigned char* key, unsigned keyLength, const unsigned char* initData, unsigned initDataLength, const String& sessionId)
482 {
483     if (!m_webMediaPlayer)
484         return MediaPlayer::InvalidPlayerState;
485
486     WebMediaPlayer::MediaKeyException result = m_webMediaPlayer->addKey(keySystem, key, keyLength, initData, initDataLength, sessionId);
487     return static_cast<MediaPlayer::MediaKeyException>(result);
488 }
489
490 MediaPlayer::MediaKeyException WebMediaPlayerClientImpl::cancelKeyRequest(const String& keySystem, const String& sessionId)
491 {
492     if (!m_webMediaPlayer)
493         return MediaPlayer::InvalidPlayerState;
494
495     WebMediaPlayer::MediaKeyException result = m_webMediaPlayer->cancelKeyRequest(keySystem, sessionId);
496     return static_cast<MediaPlayer::MediaKeyException>(result);
497 }
498 #endif
499
500 void WebMediaPlayerClientImpl::prepareToPlay()
501 {
502     if (m_delayingLoad)
503         startDelayedLoad();
504 }
505
506 IntSize WebMediaPlayerClientImpl::naturalSize() const
507 {
508     if (m_webMediaPlayer)
509         return m_webMediaPlayer->naturalSize();
510     return IntSize();
511 }
512
513 bool WebMediaPlayerClientImpl::hasVideo() const
514 {
515     if (m_webMediaPlayer)
516         return m_webMediaPlayer->hasVideo();
517     return false;
518 }
519
520 bool WebMediaPlayerClientImpl::hasAudio() const
521 {
522     if (m_webMediaPlayer)
523         return m_webMediaPlayer->hasAudio();
524     return false;
525 }
526
527 void WebMediaPlayerClientImpl::setVisible(bool visible)
528 {
529     if (m_webMediaPlayer)
530         m_webMediaPlayer->setVisible(visible);
531 }
532
533 float WebMediaPlayerClientImpl::duration() const
534 {
535     if (m_webMediaPlayer)
536         return m_webMediaPlayer->duration();
537     return 0.0f;
538 }
539
540 float WebMediaPlayerClientImpl::currentTime() const
541 {
542     if (m_webMediaPlayer)
543         return m_webMediaPlayer->currentTime();
544     return 0.0f;
545 }
546
547 void WebMediaPlayerClientImpl::seek(float time)
548 {
549     if (m_webMediaPlayer)
550         m_webMediaPlayer->seek(time);
551 }
552
553 bool WebMediaPlayerClientImpl::seeking() const
554 {
555     if (m_webMediaPlayer)
556         return m_webMediaPlayer->seeking();
557     return false;
558 }
559
560 void WebMediaPlayerClientImpl::setEndTime(float time)
561 {
562     if (m_webMediaPlayer)
563         m_webMediaPlayer->setEndTime(time);
564 }
565
566 void WebMediaPlayerClientImpl::setRate(float rate)
567 {
568     if (m_webMediaPlayer)
569         m_webMediaPlayer->setRate(rate);
570 }
571
572 bool WebMediaPlayerClientImpl::paused() const
573 {
574     if (m_webMediaPlayer)
575         return m_webMediaPlayer->paused();
576     return false;
577 }
578
579 bool WebMediaPlayerClientImpl::supportsFullscreen() const
580 {
581     if (m_webMediaPlayer)
582         return m_webMediaPlayer->supportsFullscreen();
583     return false;
584 }
585
586 bool WebMediaPlayerClientImpl::supportsSave() const
587 {
588     if (m_webMediaPlayer)
589         return m_webMediaPlayer->supportsSave();
590     return false;
591 }
592
593 void WebMediaPlayerClientImpl::setVolume(float volume)
594 {
595     if (m_webMediaPlayer)
596         m_webMediaPlayer->setVolume(volume);
597 }
598
599 MediaPlayer::NetworkState WebMediaPlayerClientImpl::networkState() const
600 {
601     if (m_webMediaPlayer)
602         return static_cast<MediaPlayer::NetworkState>(m_webMediaPlayer->networkState());
603     return MediaPlayer::Empty;
604 }
605
606 MediaPlayer::ReadyState WebMediaPlayerClientImpl::readyState() const
607 {
608     if (m_webMediaPlayer)
609         return static_cast<MediaPlayer::ReadyState>(m_webMediaPlayer->readyState());
610     return MediaPlayer::HaveNothing;
611 }
612
613 float WebMediaPlayerClientImpl::maxTimeSeekable() const
614 {
615     if (m_webMediaPlayer)
616         return m_webMediaPlayer->maxTimeSeekable();
617     return 0.0f;
618 }
619
620 PassRefPtr<TimeRanges> WebMediaPlayerClientImpl::buffered() const
621 {
622     if (m_webMediaPlayer) {
623         const WebTimeRanges& webRanges = m_webMediaPlayer->buffered();
624
625         // FIXME: Save the time ranges in a member variable and update it when needed.
626         RefPtr<TimeRanges> ranges = TimeRanges::create();
627         for (size_t i = 0; i < webRanges.size(); ++i)
628             ranges->add(webRanges[i].start, webRanges[i].end);
629         return ranges.release();
630     }
631     return TimeRanges::create();
632 }
633
634 int WebMediaPlayerClientImpl::dataRate() const
635 {
636     if (m_webMediaPlayer)
637         return m_webMediaPlayer->dataRate();
638     return 0;
639 }
640
641 bool WebMediaPlayerClientImpl::totalBytesKnown() const
642 {
643     if (m_webMediaPlayer)
644         return m_webMediaPlayer->totalBytesKnown();
645     return false;
646 }
647
648 unsigned WebMediaPlayerClientImpl::totalBytes() const
649 {
650     if (m_webMediaPlayer)
651         return static_cast<unsigned>(m_webMediaPlayer->totalBytes());
652     return 0;
653 }
654
655 bool WebMediaPlayerClientImpl::didLoadingProgress() const
656 {
657     return m_webMediaPlayer && m_webMediaPlayer->didLoadingProgress();
658 }
659
660 void WebMediaPlayerClientImpl::setSize(const IntSize& size)
661 {
662     if (m_webMediaPlayer)
663         m_webMediaPlayer->setSize(WebSize(size.width(), size.height()));
664 }
665
666 void WebMediaPlayerClientImpl::paint(GraphicsContext* context, const IntRect& rect)
667 {
668 #if USE(ACCELERATED_COMPOSITING)
669     // If we are using GPU to render video, ignore requests to paint frames into
670     // canvas because it will be taken care of by WebVideoLayer.
671     if (acceleratedRenderingInUse())
672         return;
673 #endif
674     paintCurrentFrameInContext(context, rect);
675 }
676
677 void WebMediaPlayerClientImpl::paintCurrentFrameInContext(GraphicsContext* context, const IntRect& rect)
678 {
679     // Normally GraphicsContext operations do nothing when painting is disabled.
680     // Since we're accessing platformContext() directly we have to manually
681     // check.
682     if (m_webMediaPlayer && !context->paintingDisabled()) {
683         PlatformGraphicsContext* platformContext = context->platformContext();
684         WebCanvas* canvas = platformContext->canvas();
685         m_webMediaPlayer->paint(canvas, rect, platformContext->getNormalizedAlpha());
686     }
687 }
688
689 void WebMediaPlayerClientImpl::setPreload(MediaPlayer::Preload preload)
690 {
691     m_preload = preload;
692
693     if (m_webMediaPlayer)
694         m_webMediaPlayer->setPreload(static_cast<WebMediaPlayer::Preload>(preload));
695
696     if (m_delayingLoad && m_preload != MediaPlayer::None)
697         startDelayedLoad();
698 }
699
700 bool WebMediaPlayerClientImpl::hasSingleSecurityOrigin() const
701 {
702     if (m_webMediaPlayer)
703         return m_webMediaPlayer->hasSingleSecurityOrigin();
704     return false;
705 }
706
707 bool WebMediaPlayerClientImpl::didPassCORSAccessCheck() const
708 {
709     if (m_webMediaPlayer)
710         return m_webMediaPlayer->didPassCORSAccessCheck();
711     return false;
712 }
713
714 MediaPlayer::MovieLoadType WebMediaPlayerClientImpl::movieLoadType() const
715 {
716     if (m_webMediaPlayer)
717         return static_cast<MediaPlayer::MovieLoadType>(
718             m_webMediaPlayer->movieLoadType());
719     return MediaPlayer::Unknown;
720 }
721
722 float WebMediaPlayerClientImpl::mediaTimeForTimeValue(float timeValue) const
723 {
724     if (m_webMediaPlayer)
725         return m_webMediaPlayer->mediaTimeForTimeValue(timeValue);
726     return timeValue;
727 }
728
729 unsigned WebMediaPlayerClientImpl::decodedFrameCount() const
730 {
731     if (m_webMediaPlayer)
732         return m_webMediaPlayer->decodedFrameCount();
733     return 0;
734 }
735
736 unsigned WebMediaPlayerClientImpl::droppedFrameCount() const
737 {
738     if (m_webMediaPlayer)
739         return m_webMediaPlayer->droppedFrameCount();
740     return 0;
741 }
742
743 unsigned WebMediaPlayerClientImpl::audioDecodedByteCount() const
744 {
745     if (m_webMediaPlayer)
746         return m_webMediaPlayer->audioDecodedByteCount();
747     return 0;
748 }
749
750 unsigned WebMediaPlayerClientImpl::videoDecodedByteCount() const
751 {
752     if (m_webMediaPlayer)
753         return m_webMediaPlayer->videoDecodedByteCount();
754     return 0;
755 }
756
757 #if ENABLE(WEB_AUDIO)
758 AudioSourceProvider* WebMediaPlayerClientImpl::audioSourceProvider()
759 {
760     return &m_audioSourceProvider;
761 }
762 #endif
763
764 #if USE(ACCELERATED_COMPOSITING)
765 bool WebMediaPlayerClientImpl::supportsAcceleratedRendering() const
766 {
767     return m_supportsAcceleratedCompositing;
768 }
769
770 bool WebMediaPlayerClientImpl::acceleratedRenderingInUse()
771 {
772     return m_videoLayer && m_videoLayer->active();
773 }
774
775 void WebMediaPlayerClientImpl::setVideoFrameProviderClient(WebVideoFrameProvider::Client* client)
776 {
777     MutexLocker locker(m_webMediaPlayerMutex);
778     if (m_videoFrameProviderClient)
779         m_videoFrameProviderClient->stopUsingProvider();
780     m_videoFrameProviderClient = client;
781     if (m_webMediaPlayer)
782         m_webMediaPlayer->setStreamTextureClient(client ? this : 0);
783 }
784
785 WebVideoFrame* WebMediaPlayerClientImpl::getCurrentFrame()
786 {
787     // This function is called only by the client.
788     MutexLocker locker(m_webMediaPlayerMutex);
789     ASSERT(!m_currentVideoFrame);
790     ASSERT(m_videoFrameProviderClient);
791     if (m_webMediaPlayer)
792         m_currentVideoFrame = m_webMediaPlayer->getCurrentFrame();
793     return m_currentVideoFrame;
794 }
795
796 void WebMediaPlayerClientImpl::putCurrentFrame(WebVideoFrame* videoFrame)
797 {
798     // This function is called only by the client.
799     MutexLocker locker(m_webMediaPlayerMutex);
800     ASSERT(videoFrame == m_currentVideoFrame);
801     ASSERT(m_videoFrameProviderClient);
802     if (!videoFrame)
803         return;
804     if (m_webMediaPlayer)
805         m_webMediaPlayer->putCurrentFrame(videoFrame);
806     m_currentVideoFrame = 0;
807 }
808 #endif
809
810 PassOwnPtr<MediaPlayerPrivateInterface> WebMediaPlayerClientImpl::create(MediaPlayer* player)
811 {
812     OwnPtr<WebMediaPlayerClientImpl> client = adoptPtr(new WebMediaPlayerClientImpl());
813     client->m_mediaPlayer = player;
814
815 #if USE(ACCELERATED_COMPOSITING)
816     Frame* frame = static_cast<HTMLMediaElement*>(
817         client->m_mediaPlayer->mediaPlayerClient())->document()->frame();
818
819     // This does not actually check whether the hardware can support accelerated
820     // compositing, but only if the flag is set. However, this is checked lazily
821     // in WebViewImpl::setIsAcceleratedCompositingActive() and will fail there
822     // if necessary.
823     client->m_supportsAcceleratedCompositing =
824         frame->contentRenderer()->compositor()->hasAcceleratedCompositing();
825 #endif
826
827     return client.release();
828 }
829
830 void WebMediaPlayerClientImpl::getSupportedTypes(HashSet<String>& supportedTypes)
831 {
832     // FIXME: integrate this list with WebMediaPlayerClientImpl::supportsType.
833     notImplemented();
834 }
835
836 #if ENABLE(ENCRYPTED_MEDIA)
837 MediaPlayer::SupportsType WebMediaPlayerClientImpl::supportsType(const String& type,
838                                                                  const String& codecs,
839                                                                  const String& keySystem,
840                                                                  const KURL&)
841 {
842 #else
843 MediaPlayer::SupportsType WebMediaPlayerClientImpl::supportsType(const String& type,
844                                                                  const String& codecs,
845                                                                  const KURL&)
846 {
847     String keySystem;
848 #endif
849     WebMimeRegistry::SupportsType supportsType = WebKit::Platform::current()->mimeRegistry()->supportsMediaMIMEType(type, codecs, keySystem);
850
851     switch (supportsType) {
852     default:
853         ASSERT_NOT_REACHED();
854     case WebMimeRegistry::IsNotSupported:
855         return MediaPlayer::IsNotSupported;
856     case WebMimeRegistry::IsSupported:
857         return MediaPlayer::IsSupported;
858     case WebMimeRegistry::MayBeSupported:
859         return MediaPlayer::MayBeSupported;
860     }
861     return MediaPlayer::IsNotSupported;
862 }
863
864 void WebMediaPlayerClientImpl::startDelayedLoad()
865 {
866     ASSERT(m_delayingLoad);
867     ASSERT(!m_webMediaPlayer);
868
869     m_delayingLoad = false;
870
871     loadInternal();
872 }
873
874 void WebMediaPlayerClientImpl::didReceiveFrame()
875 {
876     // No lock since this gets called on the client's thread.
877     m_videoFrameProviderClient->didReceiveFrame();
878 }
879
880 void WebMediaPlayerClientImpl::didUpdateMatrix(const float* matrix)
881 {
882     // No lock since this gets called on the client's thread.
883     m_videoFrameProviderClient->didUpdateMatrix(matrix);
884 }
885
886 WebMediaPlayerClientImpl::WebMediaPlayerClientImpl()
887     : m_mediaPlayer(0)
888     , m_currentVideoFrame(0)
889     , m_delayingLoad(false)
890     , m_preload(MediaPlayer::MetaData)
891 #if USE(ACCELERATED_COMPOSITING)
892     , m_supportsAcceleratedCompositing(false)
893     , m_opaque(false)
894     , m_videoFrameProviderClient(0)
895 #endif
896 {
897 }
898
899 #if ENABLE(WEB_AUDIO)
900 void WebMediaPlayerClientImpl::AudioSourceProviderImpl::wrap(WebAudioSourceProvider* provider)
901 {
902     m_webAudioSourceProvider = provider;
903     if (m_webAudioSourceProvider)
904         m_webAudioSourceProvider->setClient(m_client.get());
905 }
906
907 void WebMediaPlayerClientImpl::AudioSourceProviderImpl::setClient(AudioSourceProviderClient* client)
908 {
909     if (client)
910         m_client = adoptPtr(new WebMediaPlayerClientImpl::AudioClientImpl(client));
911     else
912         m_client.clear();
913
914     if (m_webAudioSourceProvider)
915         m_webAudioSourceProvider->setClient(m_client.get());
916 }
917
918 void WebMediaPlayerClientImpl::AudioSourceProviderImpl::provideInput(AudioBus* bus, size_t framesToProcess)
919 {
920     ASSERT(bus);
921     if (!bus)
922         return;
923
924     if (!m_webAudioSourceProvider) {
925         bus->zero();
926         return;
927     }
928
929     // Wrap the AudioBus channel data using WebVector.
930     size_t n = bus->numberOfChannels();
931     WebVector<float*> webAudioData(n);
932     for (size_t i = 0; i < n; ++i)
933         webAudioData[i] = bus->channel(i)->mutableData();
934
935     m_webAudioSourceProvider->provideInput(webAudioData, framesToProcess);
936 }
937
938 void WebMediaPlayerClientImpl::AudioClientImpl::setFormat(size_t numberOfChannels, float sampleRate)
939 {
940     if (m_client)
941         m_client->setFormat(numberOfChannels, sampleRate);
942 }
943
944 #endif
945
946 } // namespace WebKit
947
948 #endif  // ENABLE(VIDEO)