Expose a flag so that fullscreen video on android can work with FULLSCREEN_API
[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 "VideoLayerChromium.h"
23 #include "WebAudioSourceProvider.h"
24 #include "WebFrameClient.h"
25 #include "WebFrameImpl.h"
26 #include "WebKit.h"
27 #include "WebMediaPlayer.h"
28 #include "WebViewImpl.h"
29 #include "cc/CCProxy.h"
30 #include "platform/WebCString.h"
31 #include "platform/WebCanvas.h"
32 #include "platform/WebKitPlatformSupport.h"
33 #include "platform/WebRect.h"
34 #include "platform/WebSize.h"
35 #include "platform/WebString.h"
36 #include "platform/WebURL.h"
37 #include <public/WebMimeRegistry.h>
38
39 #if USE(ACCELERATED_COMPOSITING)
40 #include "RenderLayerCompositor.h"
41 #endif
42
43 #include <wtf/Assertions.h>
44 #include <wtf/text/CString.h>
45
46 using namespace WebCore;
47
48 namespace WebKit {
49
50 static PassOwnPtr<WebMediaPlayer> createWebMediaPlayer(WebMediaPlayerClient* client, Frame* frame)
51 {
52     WebFrameImpl* webFrame = WebFrameImpl::fromFrame(frame);
53
54     if (!webFrame->client())
55         return nullptr;
56     return adoptPtr(webFrame->client()->createMediaPlayer(webFrame, client));
57 }
58
59 bool WebMediaPlayerClientImpl::m_isEnabled = false;
60
61 bool WebMediaPlayerClientImpl::isEnabled()
62 {
63     return m_isEnabled;
64 }
65
66 void WebMediaPlayerClientImpl::setIsEnabled(bool isEnabled)
67 {
68     m_isEnabled = isEnabled;
69 }
70
71 void WebMediaPlayerClientImpl::registerSelf(MediaEngineRegistrar registrar)
72 {
73     if (m_isEnabled) {
74         registrar(WebMediaPlayerClientImpl::create,
75                   WebMediaPlayerClientImpl::getSupportedTypes,
76                   WebMediaPlayerClientImpl::supportsType,
77                   0,
78                   0,
79                   0);
80     }
81 }
82
83 WebMediaPlayer* WebMediaPlayerClientImpl::mediaPlayer() const
84 {
85     return m_webMediaPlayer.get();
86 }
87
88 // WebMediaPlayerClient --------------------------------------------------------
89
90 WebMediaPlayerClientImpl::~WebMediaPlayerClientImpl()
91 {
92 #if USE(ACCELERATED_COMPOSITING)
93     MutexLocker locker(m_compositingMutex);
94     if (m_videoFrameProviderClient)
95         m_videoFrameProviderClient->stopUsingProvider();
96     if (m_webMediaPlayer)
97         m_webMediaPlayer->setStreamTextureClient(0);
98 #endif
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.isNull()) {
113         m_videoLayer = WebVideoLayer::create(this);
114         m_videoLayer.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.isNull() && supportsAcceleratedRendering())
142         m_videoLayer.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.isNull())
170         m_videoLayer.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 void WebMediaPlayerClientImpl::disableAcceleratedCompositing()
269 {
270     m_supportsAcceleratedCompositing = false;
271 }
272
273 // MediaPlayerPrivateInterface -------------------------------------------------
274
275 void WebMediaPlayerClientImpl::load(const String& url)
276 {
277     m_url = url;
278
279     if (m_preload == MediaPlayer::None) {
280         MutexLocker locker(m_compositingMutex);
281 #if ENABLE(WEB_AUDIO)
282         m_audioSourceProvider.wrap(0); // Clear weak reference to m_webMediaPlayer's WebAudioSourceProvider.
283 #endif
284         m_webMediaPlayer.clear();
285         m_delayingLoad = true;
286     } else
287         loadInternal();
288 }
289
290 void WebMediaPlayerClientImpl::loadInternal()
291 {
292     MutexLocker locker(m_compositingMutex);
293 #if ENABLE(WEB_AUDIO)
294     m_audioSourceProvider.wrap(0); // Clear weak reference to m_webMediaPlayer's WebAudioSourceProvider.
295 #endif
296
297     Frame* frame = static_cast<HTMLMediaElement*>(m_mediaPlayer->mediaPlayerClient())->document()->frame();
298     m_webMediaPlayer = createWebMediaPlayer(this, frame);
299     if (m_webMediaPlayer) {
300 #if ENABLE(WEB_AUDIO)
301         // Make sure if we create/re-create the WebMediaPlayer that we update our wrapper.
302         m_audioSourceProvider.wrap(m_webMediaPlayer->audioSourceProvider());
303 #endif
304         m_webMediaPlayer->load(KURL(ParsedURLString, m_url));
305     }
306 }
307
308 void WebMediaPlayerClientImpl::cancelLoad()
309 {
310     if (m_webMediaPlayer)
311         m_webMediaPlayer->cancelLoad();
312 }
313
314 #if USE(ACCELERATED_COMPOSITING)
315 PlatformLayer* WebMediaPlayerClientImpl::platformLayer() const
316 {
317     ASSERT(m_supportsAcceleratedCompositing);
318     return m_videoLayer.unwrap<VideoLayerChromium>();
319 }
320 #endif
321
322 PlatformMedia WebMediaPlayerClientImpl::platformMedia() const
323 {
324     PlatformMedia pm;
325     pm.type = PlatformMedia::ChromiumMediaPlayerType;
326     pm.media.chromiumMediaPlayer = const_cast<WebMediaPlayerClientImpl*>(this);
327     return pm;
328 }
329
330 void WebMediaPlayerClientImpl::play()
331 {
332     if (m_webMediaPlayer)
333         m_webMediaPlayer->play();
334 }
335
336 void WebMediaPlayerClientImpl::pause()
337 {
338     if (m_webMediaPlayer)
339         m_webMediaPlayer->pause();
340 }
341
342 #if ENABLE(NATIVE_FULLSCREEN_VIDEO)
343 bool WebMediaPlayerClientImpl::enterFullscreen() const
344 {
345     if (m_webMediaPlayer)
346         return m_webMediaPlayer->enterFullscreen();
347     return false;
348 }
349
350 void WebMediaPlayerClientImpl::exitFullscreen()
351 {
352     if (m_webMediaPlayer)
353         m_webMediaPlayer->exitFullscreen();
354 }
355 #endif
356
357 #if ENABLE(MEDIA_SOURCE)
358 WebCore::MediaPlayer::AddIdStatus WebMediaPlayerClientImpl::sourceAddId(const String& id, const String& type)
359 {
360     if (!m_webMediaPlayer)
361         return WebCore::MediaPlayer::NotSupported;
362
363     return static_cast<WebCore::MediaPlayer::AddIdStatus>(m_webMediaPlayer->sourceAddId(id, type));
364 }
365
366 bool WebMediaPlayerClientImpl::sourceRemoveId(const String& id)
367 {
368     if (!m_webMediaPlayer)
369         return false;
370
371     return m_webMediaPlayer->sourceRemoveId(id);
372 }
373
374 bool WebMediaPlayerClientImpl::sourceAppend(const unsigned char* data, unsigned length)
375 {
376     if (m_webMediaPlayer)
377         return m_webMediaPlayer->sourceAppend(data, length);
378     return false;
379 }
380
381 void WebMediaPlayerClientImpl::sourceEndOfStream(WebCore::MediaPlayer::EndOfStreamStatus status)
382 {
383     if (m_webMediaPlayer)
384         m_webMediaPlayer->sourceEndOfStream(static_cast<WebMediaPlayer::EndOfStreamStatus>(status));
385 }
386 #endif
387
388 #if ENABLE(ENCRYPTED_MEDIA)
389 MediaPlayer::MediaKeyException WebMediaPlayerClientImpl::generateKeyRequest(const String& keySystem, const unsigned char* initData, unsigned initDataLength)
390 {
391     if (!m_webMediaPlayer)
392         return MediaPlayer::InvalidPlayerState;
393
394     WebMediaPlayer::MediaKeyException result = m_webMediaPlayer->generateKeyRequest(keySystem, initData, initDataLength);
395     return static_cast<MediaPlayer::MediaKeyException>(result);
396 }
397
398 MediaPlayer::MediaKeyException WebMediaPlayerClientImpl::addKey(const String& keySystem, const unsigned char* key, unsigned keyLength, const unsigned char* initData, unsigned initDataLength, const String& sessionId)
399 {
400     if (!m_webMediaPlayer)
401         return MediaPlayer::InvalidPlayerState;
402
403     WebMediaPlayer::MediaKeyException result = m_webMediaPlayer->addKey(keySystem, key, keyLength, initData, initDataLength, sessionId);
404     return static_cast<MediaPlayer::MediaKeyException>(result);
405 }
406
407 MediaPlayer::MediaKeyException WebMediaPlayerClientImpl::cancelKeyRequest(const String& keySystem, const String& sessionId)
408 {
409     if (!m_webMediaPlayer)
410         return MediaPlayer::InvalidPlayerState;
411
412     WebMediaPlayer::MediaKeyException result = m_webMediaPlayer->cancelKeyRequest(keySystem, sessionId);
413     return static_cast<MediaPlayer::MediaKeyException>(result);
414 }
415 #endif
416
417 void WebMediaPlayerClientImpl::prepareToPlay()
418 {
419     if (m_delayingLoad)
420         startDelayedLoad();
421 }
422
423 IntSize WebMediaPlayerClientImpl::naturalSize() const
424 {
425     if (m_webMediaPlayer)
426         return m_webMediaPlayer->naturalSize();
427     return IntSize();
428 }
429
430 bool WebMediaPlayerClientImpl::hasVideo() const
431 {
432     if (m_webMediaPlayer)
433         return m_webMediaPlayer->hasVideo();
434     return false;
435 }
436
437 bool WebMediaPlayerClientImpl::hasAudio() const
438 {
439     if (m_webMediaPlayer)
440         return m_webMediaPlayer->hasAudio();
441     return false;
442 }
443
444 void WebMediaPlayerClientImpl::setVisible(bool visible)
445 {
446     if (m_webMediaPlayer)
447         m_webMediaPlayer->setVisible(visible);
448 }
449
450 float WebMediaPlayerClientImpl::duration() const
451 {
452     if (m_webMediaPlayer)
453         return m_webMediaPlayer->duration();
454     return 0.0f;
455 }
456
457 float WebMediaPlayerClientImpl::currentTime() const
458 {
459     if (m_webMediaPlayer)
460         return m_webMediaPlayer->currentTime();
461     return 0.0f;
462 }
463
464 void WebMediaPlayerClientImpl::seek(float time)
465 {
466     if (m_webMediaPlayer)
467         m_webMediaPlayer->seek(time);
468 }
469
470 bool WebMediaPlayerClientImpl::seeking() const
471 {
472     if (m_webMediaPlayer)
473         return m_webMediaPlayer->seeking();
474     return false;
475 }
476
477 void WebMediaPlayerClientImpl::setEndTime(float time)
478 {
479     if (m_webMediaPlayer)
480         m_webMediaPlayer->setEndTime(time);
481 }
482
483 void WebMediaPlayerClientImpl::setRate(float rate)
484 {
485     if (m_webMediaPlayer)
486         m_webMediaPlayer->setRate(rate);
487 }
488
489 bool WebMediaPlayerClientImpl::paused() const
490 {
491     if (m_webMediaPlayer)
492         return m_webMediaPlayer->paused();
493     return false;
494 }
495
496 bool WebMediaPlayerClientImpl::supportsFullscreen() const
497 {
498     if (m_webMediaPlayer)
499         return m_webMediaPlayer->supportsFullscreen();
500     return false;
501 }
502
503 bool WebMediaPlayerClientImpl::supportsSave() const
504 {
505     if (m_webMediaPlayer)
506         return m_webMediaPlayer->supportsSave();
507     return false;
508 }
509
510 void WebMediaPlayerClientImpl::setVolume(float volume)
511 {
512     if (m_webMediaPlayer)
513         m_webMediaPlayer->setVolume(volume);
514 }
515
516 MediaPlayer::NetworkState WebMediaPlayerClientImpl::networkState() const
517 {
518     if (m_webMediaPlayer)
519         return static_cast<MediaPlayer::NetworkState>(m_webMediaPlayer->networkState());
520     return MediaPlayer::Empty;
521 }
522
523 MediaPlayer::ReadyState WebMediaPlayerClientImpl::readyState() const
524 {
525     if (m_webMediaPlayer)
526         return static_cast<MediaPlayer::ReadyState>(m_webMediaPlayer->readyState());
527     return MediaPlayer::HaveNothing;
528 }
529
530 float WebMediaPlayerClientImpl::maxTimeSeekable() const
531 {
532     if (m_webMediaPlayer)
533         return m_webMediaPlayer->maxTimeSeekable();
534     return 0.0f;
535 }
536
537 PassRefPtr<TimeRanges> WebMediaPlayerClientImpl::buffered() const
538 {
539     if (m_webMediaPlayer) {
540         const WebTimeRanges& webRanges = m_webMediaPlayer->buffered();
541
542         // FIXME: Save the time ranges in a member variable and update it when needed.
543         RefPtr<TimeRanges> ranges = TimeRanges::create();
544         for (size_t i = 0; i < webRanges.size(); ++i)
545             ranges->add(webRanges[i].start, webRanges[i].end);
546         return ranges.release();
547     }
548     return TimeRanges::create();
549 }
550
551 int WebMediaPlayerClientImpl::dataRate() const
552 {
553     if (m_webMediaPlayer)
554         return m_webMediaPlayer->dataRate();
555     return 0;
556 }
557
558 bool WebMediaPlayerClientImpl::totalBytesKnown() const
559 {
560     if (m_webMediaPlayer)
561         return m_webMediaPlayer->totalBytesKnown();
562     return false;
563 }
564
565 unsigned WebMediaPlayerClientImpl::totalBytes() const
566 {
567     if (m_webMediaPlayer)
568         return static_cast<unsigned>(m_webMediaPlayer->totalBytes());
569     return 0;
570 }
571
572 unsigned WebMediaPlayerClientImpl::bytesLoaded() const
573 {
574     if (m_webMediaPlayer)
575         return static_cast<unsigned>(m_webMediaPlayer->bytesLoaded());
576     return 0;
577 }
578
579 void WebMediaPlayerClientImpl::setSize(const IntSize& size)
580 {
581     if (m_webMediaPlayer)
582         m_webMediaPlayer->setSize(WebSize(size.width(), size.height()));
583 }
584
585 void WebMediaPlayerClientImpl::paint(GraphicsContext* context, const IntRect& rect)
586 {
587 #if USE(ACCELERATED_COMPOSITING)
588     // If we are using GPU to render video, ignore requests to paint frames into
589     // canvas because it will be taken care of by VideoLayerChromium.
590     if (acceleratedRenderingInUse())
591         return;
592 #endif
593     paintCurrentFrameInContext(context, rect);
594 }
595
596 void WebMediaPlayerClientImpl::paintCurrentFrameInContext(GraphicsContext* context, const IntRect& rect)
597 {
598     // Normally GraphicsContext operations do nothing when painting is disabled.
599     // Since we're accessing platformContext() directly we have to manually
600     // check.
601     if (m_webMediaPlayer && !context->paintingDisabled()) {
602         PlatformGraphicsContext* platformContext = context->platformContext();
603         WebCanvas* canvas = platformContext->canvas();
604         m_webMediaPlayer->paint(canvas, rect, platformContext->getNormalizedAlpha());
605     }
606 }
607
608 void WebMediaPlayerClientImpl::setPreload(MediaPlayer::Preload preload)
609 {
610     m_preload = preload;
611
612     if (m_webMediaPlayer)
613         m_webMediaPlayer->setPreload(static_cast<WebMediaPlayer::Preload>(preload));
614
615     if (m_delayingLoad && m_preload != MediaPlayer::None)
616         startDelayedLoad();
617 }
618
619 bool WebMediaPlayerClientImpl::hasSingleSecurityOrigin() const
620 {
621     if (m_webMediaPlayer)
622         return m_webMediaPlayer->hasSingleSecurityOrigin();
623     return false;
624 }
625
626 MediaPlayer::MovieLoadType WebMediaPlayerClientImpl::movieLoadType() const
627 {
628     if (m_webMediaPlayer)
629         return static_cast<MediaPlayer::MovieLoadType>(
630             m_webMediaPlayer->movieLoadType());
631     return MediaPlayer::Unknown;
632 }
633
634 float WebMediaPlayerClientImpl::mediaTimeForTimeValue(float timeValue) const
635 {
636     if (m_webMediaPlayer)
637         return m_webMediaPlayer->mediaTimeForTimeValue(timeValue);
638     return timeValue;
639 }
640
641 unsigned WebMediaPlayerClientImpl::decodedFrameCount() const
642 {
643     if (m_webMediaPlayer)
644         return m_webMediaPlayer->decodedFrameCount();
645     return 0;
646 }
647
648 unsigned WebMediaPlayerClientImpl::droppedFrameCount() const
649 {
650     if (m_webMediaPlayer)
651         return m_webMediaPlayer->droppedFrameCount();
652     return 0;
653 }
654
655 unsigned WebMediaPlayerClientImpl::audioDecodedByteCount() const
656 {
657     if (m_webMediaPlayer)
658         return m_webMediaPlayer->audioDecodedByteCount();
659     return 0;
660 }
661
662 unsigned WebMediaPlayerClientImpl::videoDecodedByteCount() const
663 {
664     if (m_webMediaPlayer)
665         return m_webMediaPlayer->videoDecodedByteCount();
666     return 0;
667 }
668
669 #if ENABLE(WEB_AUDIO)
670 AudioSourceProvider* WebMediaPlayerClientImpl::audioSourceProvider()
671 {
672     return &m_audioSourceProvider;
673 }
674 #endif
675
676 #if USE(ACCELERATED_COMPOSITING)
677 bool WebMediaPlayerClientImpl::supportsAcceleratedRendering() const
678 {
679     return m_supportsAcceleratedCompositing;
680 }
681
682 bool WebMediaPlayerClientImpl::acceleratedRenderingInUse()
683 {
684     return !m_videoLayer.isNull() && m_videoLayer.active();
685 }
686
687 void WebMediaPlayerClientImpl::setVideoFrameProviderClient(WebVideoFrameProvider::Client* client)
688 {
689     MutexLocker locker(m_compositingMutex);
690     m_videoFrameProviderClient = client;
691     if (m_webMediaPlayer)
692         m_webMediaPlayer->setStreamTextureClient(client ? this : 0);
693 }
694
695 WebVideoFrame* WebMediaPlayerClientImpl::getCurrentFrame()
696 {
697     MutexLocker locker(m_compositingMutex);
698     ASSERT(!m_currentVideoFrame);
699     if (m_webMediaPlayer)
700         m_currentVideoFrame = m_webMediaPlayer->getCurrentFrame();
701     return m_currentVideoFrame;
702 }
703
704 void WebMediaPlayerClientImpl::putCurrentFrame(WebVideoFrame* videoFrame)
705 {
706     MutexLocker locker(m_compositingMutex);
707     ASSERT(videoFrame == m_currentVideoFrame);
708     if (!videoFrame)
709         return;
710     if (m_webMediaPlayer)
711         m_webMediaPlayer->putCurrentFrame(videoFrame);
712     m_currentVideoFrame = 0;
713 }
714 #endif
715
716 PassOwnPtr<MediaPlayerPrivateInterface> WebMediaPlayerClientImpl::create(MediaPlayer* player)
717 {
718     OwnPtr<WebMediaPlayerClientImpl> client = adoptPtr(new WebMediaPlayerClientImpl());
719     client->m_mediaPlayer = player;
720
721 #if USE(ACCELERATED_COMPOSITING)
722     Frame* frame = static_cast<HTMLMediaElement*>(
723         client->m_mediaPlayer->mediaPlayerClient())->document()->frame();
724
725     // This does not actually check whether the hardware can support accelerated
726     // compositing, but only if the flag is set. However, this is checked lazily
727     // in WebViewImpl::setIsAcceleratedCompositingActive() and will fail there
728     // if necessary.
729     client->m_supportsAcceleratedCompositing =
730         frame->contentRenderer()->compositor()->hasAcceleratedCompositing();
731 #endif
732
733     return client.release();
734 }
735
736 void WebMediaPlayerClientImpl::getSupportedTypes(HashSet<String>& supportedTypes)
737 {
738     // FIXME: integrate this list with WebMediaPlayerClientImpl::supportsType.
739     notImplemented();
740 }
741
742 #if ENABLE(ENCRYPTED_MEDIA)
743 MediaPlayer::SupportsType WebMediaPlayerClientImpl::supportsType(const String& type,
744                                                                  const String& codecs,
745                                                                  const String& keySystem)
746 {
747 #else
748 MediaPlayer::SupportsType WebMediaPlayerClientImpl::supportsType(const String& type,
749                                                                  const String& codecs)
750 {
751     String keySystem;
752 #endif
753     WebMimeRegistry::SupportsType supportsType = webKitPlatformSupport()->mimeRegistry()->supportsMediaMIMEType(type, codecs, keySystem);
754
755     switch (supportsType) {
756     default:
757         ASSERT_NOT_REACHED();
758     case WebMimeRegistry::IsNotSupported:
759         return MediaPlayer::IsNotSupported;
760     case WebMimeRegistry::IsSupported:
761         return MediaPlayer::IsSupported;
762     case WebMimeRegistry::MayBeSupported:
763         return MediaPlayer::MayBeSupported;
764     }
765     return MediaPlayer::IsNotSupported;
766 }
767
768 void WebMediaPlayerClientImpl::startDelayedLoad()
769 {
770     ASSERT(m_delayingLoad);
771     ASSERT(!m_webMediaPlayer);
772
773     m_delayingLoad = false;
774
775     loadInternal();
776 }
777
778 void WebMediaPlayerClientImpl::didReceiveFrame()
779 {
780     // No lock since this gets called on the client's thread.
781     ASSERT(CCProxy::isImplThread());
782     m_videoFrameProviderClient->didReceiveFrame();
783 }
784
785 void WebMediaPlayerClientImpl::didUpdateMatrix(const float* matrix)
786 {
787     // No lock since this gets called on the client's thread.
788     ASSERT(CCProxy::isImplThread());
789     m_videoFrameProviderClient->didUpdateMatrix(matrix);
790 }
791
792 WebMediaPlayerClientImpl::WebMediaPlayerClientImpl()
793     : m_mediaPlayer(0)
794     , m_currentVideoFrame(0)
795     , m_delayingLoad(false)
796     , m_preload(MediaPlayer::MetaData)
797 #if USE(ACCELERATED_COMPOSITING)
798     , m_supportsAcceleratedCompositing(false)
799     , m_opaque(false)
800     , m_videoFrameProviderClient(0)
801 #endif
802 {
803 }
804
805 #if ENABLE(WEB_AUDIO)
806 void WebMediaPlayerClientImpl::AudioSourceProviderImpl::wrap(WebAudioSourceProvider* provider)
807 {
808     m_webAudioSourceProvider = provider;
809     if (m_webAudioSourceProvider)
810         m_webAudioSourceProvider->setClient(m_client.get());
811 }
812
813 void WebMediaPlayerClientImpl::AudioSourceProviderImpl::setClient(AudioSourceProviderClient* client)
814 {
815     if (client)
816         m_client = adoptPtr(new WebMediaPlayerClientImpl::AudioClientImpl(client));
817     else
818         m_client.clear();
819
820     if (m_webAudioSourceProvider)
821         m_webAudioSourceProvider->setClient(m_client.get());
822 }
823
824 void WebMediaPlayerClientImpl::AudioSourceProviderImpl::provideInput(AudioBus* bus, size_t framesToProcess)
825 {
826     ASSERT(bus);
827     if (!bus)
828         return;
829
830     if (!m_webAudioSourceProvider) {
831         bus->zero();
832         return;
833     }
834
835     // Wrap the AudioBus channel data using WebVector.
836     size_t n = bus->numberOfChannels();
837     WebVector<float*> webAudioData(n);
838     for (size_t i = 0; i < n; ++i)
839         webAudioData[i] = bus->channel(i)->mutableData();
840
841     m_webAudioSourceProvider->provideInput(webAudioData, framesToProcess);
842 }
843
844 void WebMediaPlayerClientImpl::AudioClientImpl::setFormat(size_t numberOfChannels, float sampleRate)
845 {
846     if (m_client)
847         m_client->setFormat(numberOfChannels, sampleRate);
848 }
849
850 #endif
851
852 } // namespace WebKit
853
854 #endif  // ENABLE(VIDEO)