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.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 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 const_cast<WebVideoLayer*>(&m_videoLayer);
 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.isNull() && 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)