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