Changeset 101810 in webkit


Ignore:
Timestamp:
Dec 2, 2011 9:35:54 AM (12 years ago)
Author:
jer.noble@apple.com
Message:

MediaControls should use MediaController if present.
https://bugs.webkit.org/show_bug.cgi?id=71410

Reviewed by Eric Carlson.

No new tests; covered by existing tests.

Add support for individual media controls to control the MediaController of their associated
HTMLMediaElement, if present.

The video spec requires that UA provided media controls be implemented in terms of their
HTMLMediaElement's MediaController, if present. So for each of the media controls, modify
their constructor to take a Document* instead of an HTMLMediaElement, and add an setter
taking a MediaControllerInterface.

Now that MediaControls have an abstract interface instead of an HTMLMediaElement, use toParentMediaElement
to find the controllingVideoElement.

  • accessibility/AccessibilityMediaControls.cpp:

(WebCore::AccessibilityMediaControlsContainer::controllingVideoElement):

Pass the MediaController or the HTMLMediaElement when setting up the elements controls.

  • html/HTMLMediaElement.cpp:

(WebCore::HTMLMediaElement::createMediaControls):
(WebCore::HTMLMediaElement::setMediaController):

The following functions have only constructor changes:

  • html/shadow/MediaControlElements.cpp:

(WebCore::MediaControlElement::MediaControlElement):
(WebCore::MediaControlPanelElement::MediaControlPanelElement):
(WebCore::MediaControlPanelElement::create):
(WebCore::MediaControlTimelineContainerElement::MediaControlTimelineContainerElement):
(WebCore::MediaControlTimelineContainerElement::create):
(WebCore::MediaControlVolumeSliderContainerElement::MediaControlVolumeSliderContainerElement):
(WebCore::MediaControlVolumeSliderContainerElement::create):
(WebCore::MediaControlStatusDisplayElement::MediaControlStatusDisplayElement):
(WebCore::MediaControlStatusDisplayElement::create):
(WebCore::MediaControlInputElement::MediaControlInputElement):
(WebCore::MediaControlMuteButtonElement::MediaControlMuteButtonElement):
(WebCore::MediaControlMuteButtonElement::defaultEventHandler):
(WebCore::MediaControlPanelMuteButtonElement::MediaControlPanelMuteButtonElement):
(WebCore::MediaControlPanelMuteButtonElement::create):
(WebCore::MediaControlVolumeSliderMuteButtonElement::MediaControlVolumeSliderMuteButtonElement):
(WebCore::MediaControlVolumeSliderMuteButtonElement::create):
(WebCore::MediaControlPlayButtonElement::MediaControlPlayButtonElement):
(WebCore::MediaControlPlayButtonElement::create):
(WebCore::MediaControlSeekButtonElement::MediaControlSeekButtonElement):
(WebCore::MediaControlSeekForwardButtonElement::MediaControlSeekForwardButtonElement):
(WebCore::MediaControlSeekForwardButtonElement::create):
(WebCore::MediaControlSeekBackButtonElement::MediaControlSeekBackButtonElement):
(WebCore::MediaControlSeekBackButtonElement::create):
(WebCore::MediaControlRewindButtonElement::MediaControlRewindButtonElement):
(WebCore::MediaControlRewindButtonElement::create):
(WebCore::MediaControlReturnToRealtimeButtonElement::MediaControlReturnToRealtimeButtonElement):
(WebCore::MediaControlReturnToRealtimeButtonElement::create):
(WebCore::MediaControlToggleClosedCaptionsButtonElement::MediaControlToggleClosedCaptionsButtonElement):
(WebCore::MediaControlToggleClosedCaptionsButtonElement::create):
(WebCore::MediaControlTimelineElement::MediaControlTimelineElement):
(WebCore::MediaControlTimelineElement::create):
(WebCore::MediaControlVolumeSliderElement::MediaControlVolumeSliderElement):
(WebCore::MediaControlVolumeSliderElement::create):
(WebCore::MediaControlVolumeSliderElement::defaultEventHandler):
(WebCore::MediaControlFullscreenVolumeSliderElement::MediaControlFullscreenVolumeSliderElement):
(WebCore::MediaControlFullscreenVolumeSliderElement::create):
(WebCore::MediaControlFullscreenButtonElement::MediaControlFullscreenButtonElement):
(WebCore::MediaControlFullscreenButtonElement::create):
(WebCore::MediaControlFullscreenVolumeMinButtonElement::MediaControlFullscreenVolumeMinButtonElement):
(WebCore::MediaControlFullscreenVolumeMinButtonElement::create):
(WebCore::MediaControlFullscreenVolumeMaxButtonElement::MediaControlFullscreenVolumeMaxButtonElement):
(WebCore::MediaControlFullscreenVolumeMaxButtonElement::create):
(WebCore::MediaControlTimeDisplayElement::MediaControlTimeDisplayElement):
(WebCore::MediaControlTimeRemainingDisplayElement::create):
(WebCore::MediaControlTimeRemainingDisplayElement::MediaControlTimeRemainingDisplayElement):
(WebCore::MediaControlCurrentTimeDisplayElement::create):
(WebCore::MediaControlCurrentTimeDisplayElement::MediaControlCurrentTimeDisplayElement):

  • html/shadow/MediaControlRootElement.cpp:

(WebCore::MediaControlRootElement::MediaControlRootElement):
(WebCore::MediaControls::create):
(WebCore::MediaControlRootElement::create):

  • html/shadow/MediaControlRootElement.h:
  • html/shadow/MediaControls.cpp:

(WebCore::MediaControls::MediaControls):

  • html/shadow/MediaControls.h:

The following functions now call MediaControllerInterface instead of HTMLMediaElement directly:

  • html/shadow/MediaControlElements.h:

(WebCore::MediaControlStatusDisplayElement::update):
(WebCore::MediaControlMuteButtonElement::updateDisplayType):
(WebCore::MediaControlPlayButtonElement::defaultEventHandler):
(WebCore::MediaControlPlayButtonElement::updateDisplayType):
(WebCore::MediaControlSeekButtonElement::startTimer):
(WebCore::MediaControlSeekButtonElement::stopTimer):
(WebCore::MediaControlSeekButtonElement::nextRate):
(WebCore::MediaControlSeekButtonElement::seekTimerFired):
(WebCore::MediaControlRewindButtonElement::defaultEventHandler):
(WebCore::MediaControlReturnToRealtimeButtonElement::defaultEventHandler):
(WebCore::MediaControlToggleClosedCaptionsButtonElement::defaultEventHandler):
(WebCore::MediaControlToggleClosedCaptionsButtonElement::updateDisplayType):
(WebCore::MediaControlTimelineElement::defaultEventHandler):
(WebCore::MediaControlFullscreenButtonElement::defaultEventHandler):
(WebCore::MediaControlFullscreenVolumeMinButtonElement::defaultEventHandler):
(WebCore::MediaControlFullscreenVolumeMaxButtonElement::defaultEventHandler):

  • html/shadow/MediaControlRootElement.cpp:

(WebCore::MediaControlRootElement::reset):
(WebCore::MediaControlRootElement::playbackStarted):
(WebCore::MediaControlRootElement::playbackProgressed):
(WebCore::MediaControlRootElement::playbackStopped):
(WebCore::MediaControlRootElement::updateTimeDisplay):
(WebCore::MediaControlRootElement::loadedMetadata):
(WebCore::MediaControlRootElement::changedVolume):
(WebCore::MediaControlRootElement::enteredFullscreen):
(WebCore::MediaControlRootElement::showVolumeSlider):
(WebCore::MediaControlRootElement::defaultEventHandler):
(WebCore::MediaControlRootElement::startHideFullscreenControlsTimer):
(WebCore::MediaControlRootElement::hideFullscreenControlsTimerFired):

  • html/shadow/MediaControlRootElementChromium.cpp:

(WebCore::MediaControlRootElementChromium::MediaControlRootElementChromium):
(WebCore::MediaControls::create):
(WebCore::MediaControlRootElementChromium::create):
(WebCore::MediaControlRootElementChromium::reset):
(WebCore::MediaControlRootElementChromium::playbackStarted):
(WebCore::MediaControlRootElementChromium::playbackProgressed):
(WebCore::MediaControlRootElementChromium::playbackStopped):
(WebCore::MediaControlRootElementChromium::updateTimeDisplay):
(WebCore::MediaControlRootElementChromium::defaultEventHandler):
(WebCore::MediaControlRootElementChromium::changedVolume):
(WebCore::MediaControlRootElementChromium::showVolumeSlider):

  • html/shadow/MediaControlRootElementChromium.h:

The following functions set the current MediaControllerInterface.

  • html/shadow/MediaControlRootElement.cpp:

(WebCore::MediaControlRootElement::setMediaController):

  • html/shadow/MediaControlElements.h:

(WebCore::MediaControlElement::setMediaController):
(WebCore::MediaControlElement::mediaController):
(WebCore::MediaControlInputElement::setMediaController):
(WebCore::MediaControlInputElement::mediaController):

  • html/shadow/MediaControlRootElementChromium.cpp:

(WebCore::MediaControlRootElementChromium::setMediaController):

Location:
trunk/Source/WebCore
Files:
11 edited

Legend:

Unmodified
Added
Removed
  • trunk/Source/WebCore/ChangeLog

    r101805 r101810  
     12011-11-02  Jer Noble  <jer.noble@apple.com>
     2
     3        MediaControls should use MediaController if present.
     4        https://bugs.webkit.org/show_bug.cgi?id=71410
     5
     6        Reviewed by Eric Carlson.
     7
     8        No new tests; covered by existing tests.
     9
     10        Add support for individual media controls to control the MediaController of their associated
     11        HTMLMediaElement, if present.
     12
     13        The video spec requires that UA provided media controls be implemented in terms of their
     14        HTMLMediaElement's MediaController, if present.  So for each of the media controls, modify
     15        their constructor to take a Document* instead of an HTMLMediaElement, and add an setter
     16        taking a MediaControllerInterface.
     17
     18        Now that MediaControls have an abstract interface instead of an HTMLMediaElement, use toParentMediaElement
     19        to find the controllingVideoElement.
     20        * accessibility/AccessibilityMediaControls.cpp:
     21        (WebCore::AccessibilityMediaControlsContainer::controllingVideoElement):
     22
     23        Pass the MediaController or the HTMLMediaElement when setting up the elements controls.
     24        * html/HTMLMediaElement.cpp:
     25        (WebCore::HTMLMediaElement::createMediaControls):
     26        (WebCore::HTMLMediaElement::setMediaController):
     27
     28        The following functions have only constructor changes:
     29        * html/shadow/MediaControlElements.cpp:
     30        (WebCore::MediaControlElement::MediaControlElement):
     31        (WebCore::MediaControlPanelElement::MediaControlPanelElement):
     32        (WebCore::MediaControlPanelElement::create):
     33        (WebCore::MediaControlTimelineContainerElement::MediaControlTimelineContainerElement):
     34        (WebCore::MediaControlTimelineContainerElement::create):
     35        (WebCore::MediaControlVolumeSliderContainerElement::MediaControlVolumeSliderContainerElement):
     36        (WebCore::MediaControlVolumeSliderContainerElement::create):
     37        (WebCore::MediaControlStatusDisplayElement::MediaControlStatusDisplayElement):
     38        (WebCore::MediaControlStatusDisplayElement::create):
     39        (WebCore::MediaControlInputElement::MediaControlInputElement):
     40        (WebCore::MediaControlMuteButtonElement::MediaControlMuteButtonElement):
     41        (WebCore::MediaControlMuteButtonElement::defaultEventHandler):
     42        (WebCore::MediaControlPanelMuteButtonElement::MediaControlPanelMuteButtonElement):
     43        (WebCore::MediaControlPanelMuteButtonElement::create):
     44        (WebCore::MediaControlVolumeSliderMuteButtonElement::MediaControlVolumeSliderMuteButtonElement):
     45        (WebCore::MediaControlVolumeSliderMuteButtonElement::create):
     46        (WebCore::MediaControlPlayButtonElement::MediaControlPlayButtonElement):
     47        (WebCore::MediaControlPlayButtonElement::create):
     48        (WebCore::MediaControlSeekButtonElement::MediaControlSeekButtonElement):
     49        (WebCore::MediaControlSeekForwardButtonElement::MediaControlSeekForwardButtonElement):
     50        (WebCore::MediaControlSeekForwardButtonElement::create):
     51        (WebCore::MediaControlSeekBackButtonElement::MediaControlSeekBackButtonElement):
     52        (WebCore::MediaControlSeekBackButtonElement::create):
     53        (WebCore::MediaControlRewindButtonElement::MediaControlRewindButtonElement):
     54        (WebCore::MediaControlRewindButtonElement::create):
     55        (WebCore::MediaControlReturnToRealtimeButtonElement::MediaControlReturnToRealtimeButtonElement):
     56        (WebCore::MediaControlReturnToRealtimeButtonElement::create):
     57        (WebCore::MediaControlToggleClosedCaptionsButtonElement::MediaControlToggleClosedCaptionsButtonElement):
     58        (WebCore::MediaControlToggleClosedCaptionsButtonElement::create):
     59        (WebCore::MediaControlTimelineElement::MediaControlTimelineElement):
     60        (WebCore::MediaControlTimelineElement::create):
     61        (WebCore::MediaControlVolumeSliderElement::MediaControlVolumeSliderElement):
     62        (WebCore::MediaControlVolumeSliderElement::create):
     63        (WebCore::MediaControlVolumeSliderElement::defaultEventHandler):
     64        (WebCore::MediaControlFullscreenVolumeSliderElement::MediaControlFullscreenVolumeSliderElement):
     65        (WebCore::MediaControlFullscreenVolumeSliderElement::create):
     66        (WebCore::MediaControlFullscreenButtonElement::MediaControlFullscreenButtonElement):
     67        (WebCore::MediaControlFullscreenButtonElement::create):
     68        (WebCore::MediaControlFullscreenVolumeMinButtonElement::MediaControlFullscreenVolumeMinButtonElement):
     69        (WebCore::MediaControlFullscreenVolumeMinButtonElement::create):
     70        (WebCore::MediaControlFullscreenVolumeMaxButtonElement::MediaControlFullscreenVolumeMaxButtonElement):
     71        (WebCore::MediaControlFullscreenVolumeMaxButtonElement::create):
     72        (WebCore::MediaControlTimeDisplayElement::MediaControlTimeDisplayElement):
     73        (WebCore::MediaControlTimeRemainingDisplayElement::create):
     74        (WebCore::MediaControlTimeRemainingDisplayElement::MediaControlTimeRemainingDisplayElement):
     75        (WebCore::MediaControlCurrentTimeDisplayElement::create):
     76        (WebCore::MediaControlCurrentTimeDisplayElement::MediaControlCurrentTimeDisplayElement):
     77        * html/shadow/MediaControlRootElement.cpp:
     78        (WebCore::MediaControlRootElement::MediaControlRootElement):
     79        (WebCore::MediaControls::create):
     80        (WebCore::MediaControlRootElement::create):
     81        * html/shadow/MediaControlRootElement.h:
     82        * html/shadow/MediaControls.cpp:
     83        (WebCore::MediaControls::MediaControls):
     84        * html/shadow/MediaControls.h:
     85
     86        The following functions now call MediaControllerInterface instead of HTMLMediaElement directly:
     87        * html/shadow/MediaControlElements.h:
     88        (WebCore::MediaControlStatusDisplayElement::update):
     89        (WebCore::MediaControlMuteButtonElement::updateDisplayType):
     90        (WebCore::MediaControlPlayButtonElement::defaultEventHandler):
     91        (WebCore::MediaControlPlayButtonElement::updateDisplayType):
     92        (WebCore::MediaControlSeekButtonElement::startTimer):
     93        (WebCore::MediaControlSeekButtonElement::stopTimer):
     94        (WebCore::MediaControlSeekButtonElement::nextRate):
     95        (WebCore::MediaControlSeekButtonElement::seekTimerFired):
     96        (WebCore::MediaControlRewindButtonElement::defaultEventHandler):
     97        (WebCore::MediaControlReturnToRealtimeButtonElement::defaultEventHandler):
     98        (WebCore::MediaControlToggleClosedCaptionsButtonElement::defaultEventHandler):
     99        (WebCore::MediaControlToggleClosedCaptionsButtonElement::updateDisplayType):
     100        (WebCore::MediaControlTimelineElement::defaultEventHandler):
     101        (WebCore::MediaControlFullscreenButtonElement::defaultEventHandler):
     102        (WebCore::MediaControlFullscreenVolumeMinButtonElement::defaultEventHandler):
     103        (WebCore::MediaControlFullscreenVolumeMaxButtonElement::defaultEventHandler):
     104        * html/shadow/MediaControlRootElement.cpp:
     105        (WebCore::MediaControlRootElement::reset):
     106        (WebCore::MediaControlRootElement::playbackStarted):
     107        (WebCore::MediaControlRootElement::playbackProgressed):
     108        (WebCore::MediaControlRootElement::playbackStopped):
     109        (WebCore::MediaControlRootElement::updateTimeDisplay):
     110        (WebCore::MediaControlRootElement::loadedMetadata):
     111        (WebCore::MediaControlRootElement::changedVolume):
     112        (WebCore::MediaControlRootElement::enteredFullscreen):
     113        (WebCore::MediaControlRootElement::showVolumeSlider):
     114        (WebCore::MediaControlRootElement::defaultEventHandler):
     115        (WebCore::MediaControlRootElement::startHideFullscreenControlsTimer):
     116        (WebCore::MediaControlRootElement::hideFullscreenControlsTimerFired):
     117        * html/shadow/MediaControlRootElementChromium.cpp:
     118        (WebCore::MediaControlRootElementChromium::MediaControlRootElementChromium):
     119        (WebCore::MediaControls::create):
     120        (WebCore::MediaControlRootElementChromium::create):
     121        (WebCore::MediaControlRootElementChromium::reset):
     122        (WebCore::MediaControlRootElementChromium::playbackStarted):
     123        (WebCore::MediaControlRootElementChromium::playbackProgressed):
     124        (WebCore::MediaControlRootElementChromium::playbackStopped):
     125        (WebCore::MediaControlRootElementChromium::updateTimeDisplay):
     126        (WebCore::MediaControlRootElementChromium::defaultEventHandler):
     127        (WebCore::MediaControlRootElementChromium::changedVolume):
     128        (WebCore::MediaControlRootElementChromium::showVolumeSlider):
     129        * html/shadow/MediaControlRootElementChromium.h:
     130
     131        The following functions set the current MediaControllerInterface.
     132        * html/shadow/MediaControlRootElement.cpp:
     133        (WebCore::MediaControlRootElement::setMediaController):
     134        * html/shadow/MediaControlElements.h:
     135        (WebCore::MediaControlElement::setMediaController):
     136        (WebCore::MediaControlElement::mediaController):
     137        (WebCore::MediaControlInputElement::setMediaController):
     138        (WebCore::MediaControlInputElement::mediaController):
     139        * html/shadow/MediaControlRootElementChromium.cpp:
     140        (WebCore::MediaControlRootElementChromium::setMediaController):
     141
    11422011-12-02  Stephen Chenney  <schenney@chromium.org>
    2143
  • trunk/Source/WebCore/accessibility/AccessibilityMediaControls.cpp

    r100408 r101810  
    3636#include "AXObjectCache.h"
    3737#include "HTMLInputElement.h"
     38#include "HTMLMediaElement.h"
    3839#include "HTMLNames.h"
    3940#include "LocalizedStrings.h"
     
    223224    MediaControlTimeDisplayElement* element = static_cast<MediaControlTimeDisplayElement*>(m_renderer->node());
    224225
    225     return element->mediaElement()->isVideo();
     226    return toParentMediaElement(element)->isVideo();
    226227}
    227228
  • trunk/Source/WebCore/html/HTMLMediaElement.cpp

    r101519 r101810  
    32513251
    32523252    ExceptionCode ec;
    3253     RefPtr<MediaControls> controls = MediaControls::create(this);
     3253    RefPtr<MediaControls> controls = MediaControls::create(document());
    32543254    if (!controls)
    32553255        return false;
     3256
     3257    controls->setMediaController(m_mediaController ? m_mediaController.get() : static_cast<MediaControllerInterface*>(this));
    32563258
    32573259    ensureShadowRoot()->appendChild(controls, ec);
     
    33913393    m_mediaController = controller;
    33923394
     3395    if (hasMediaControls())
     3396        mediaControls()->setMediaController(m_mediaController ? m_mediaController.get() : static_cast<MediaControllerInterface*>(this));
     3397
    33933398    if (m_mediaController)
    33943399        m_mediaController->addMediaElement(this);
  • trunk/Source/WebCore/html/shadow/MediaControlElements.cpp

    r101707 r101810  
    3838#include "FloatConversion.h"
    3939#include "Frame.h"
     40#include "HTMLMediaElement.h"
    4041#include "HTMLNames.h"
    4142#include "LocalizedStrings.h"
     
    5455
    5556using namespace HTMLNames;
     57using namespace std;
    5658
    5759// FIXME: These constants may need to be tweaked to better match the seeking in the QuickTime plug-in.
     
    8183// ----------------------------
    8284
    83 MediaControlElement::MediaControlElement(HTMLMediaElement* mediaElement)
    84     : HTMLDivElement(divTag, mediaElement->document())
    85     , m_mediaElement(mediaElement)
     85MediaControlElement::MediaControlElement(Document* document)
     86    : HTMLDivElement(divTag, document)
     87    , m_mediaController(0)
    8688{
    8789}
     
    99101// ----------------------------
    100102
    101 inline MediaControlPanelElement::MediaControlPanelElement(HTMLMediaElement* mediaElement)
    102     : MediaControlElement(mediaElement)
     103inline MediaControlPanelElement::MediaControlPanelElement(Document* document)
     104    : MediaControlElement(document)
    103105    , m_canBeDragged(false)
    104106    , m_isBeingDragged(false)
     
    107109}
    108110
    109 PassRefPtr<MediaControlPanelElement> MediaControlPanelElement::create(HTMLMediaElement* mediaElement)
    110 {
    111     return adoptRef(new MediaControlPanelElement(mediaElement));
     111PassRefPtr<MediaControlPanelElement> MediaControlPanelElement::create(Document* document)
     112{
     113    return adoptRef(new MediaControlPanelElement(document));
    112114}
    113115
     
    253255// ----------------------------
    254256
    255 inline MediaControlTimelineContainerElement::MediaControlTimelineContainerElement(HTMLMediaElement* mediaElement)
    256     : MediaControlElement(mediaElement)
    257 {
    258 }
    259 
    260 PassRefPtr<MediaControlTimelineContainerElement> MediaControlTimelineContainerElement::create(HTMLMediaElement* mediaElement)
    261 {
    262     RefPtr<MediaControlTimelineContainerElement> element = adoptRef(new MediaControlTimelineContainerElement(mediaElement));
     257inline MediaControlTimelineContainerElement::MediaControlTimelineContainerElement(Document* document)
     258    : MediaControlElement(document)
     259{
     260}
     261
     262PassRefPtr<MediaControlTimelineContainerElement> MediaControlTimelineContainerElement::create(Document* document)
     263{
     264    RefPtr<MediaControlTimelineContainerElement> element = adoptRef(new MediaControlTimelineContainerElement(document));
    263265    element->hide();
    264266    return element.release();
     
    306308}
    307309
    308 inline MediaControlVolumeSliderContainerElement::MediaControlVolumeSliderContainerElement(HTMLMediaElement* mediaElement)
    309     : MediaControlElement(mediaElement)
    310 {
    311 }
    312 
    313 PassRefPtr<MediaControlVolumeSliderContainerElement> MediaControlVolumeSliderContainerElement::create(HTMLMediaElement* mediaElement)
    314 {
    315     RefPtr<MediaControlVolumeSliderContainerElement> element = adoptRef(new MediaControlVolumeSliderContainerElement(mediaElement));
     310inline MediaControlVolumeSliderContainerElement::MediaControlVolumeSliderContainerElement(Document* document)
     311    : MediaControlElement(document)
     312{
     313}
     314
     315PassRefPtr<MediaControlVolumeSliderContainerElement> MediaControlVolumeSliderContainerElement::create(Document* document)
     316{
     317    RefPtr<MediaControlVolumeSliderContainerElement> element = adoptRef(new MediaControlVolumeSliderContainerElement(document));
    316318    element->hide();
    317319    return element.release();
     
    353355// ----------------------------
    354356
    355 inline MediaControlStatusDisplayElement::MediaControlStatusDisplayElement(HTMLMediaElement* mediaElement)
    356     : MediaControlElement(mediaElement)
     357inline MediaControlStatusDisplayElement::MediaControlStatusDisplayElement(Document* document)
     358    : MediaControlElement(document)
    357359    , m_stateBeingDisplayed(Nothing)
    358360{
    359361}
    360362
    361 PassRefPtr<MediaControlStatusDisplayElement> MediaControlStatusDisplayElement::create(HTMLMediaElement* mediaElement)
    362 {
    363     RefPtr<MediaControlStatusDisplayElement> element = adoptRef(new MediaControlStatusDisplayElement(mediaElement));
     363PassRefPtr<MediaControlStatusDisplayElement> MediaControlStatusDisplayElement::create(Document* document)
     364{
     365    RefPtr<MediaControlStatusDisplayElement> element = adoptRef(new MediaControlStatusDisplayElement(document));
    364366    element->hide();
    365367    return element.release();
     
    371373    StateBeingDisplayed newStateToDisplay = Nothing;
    372374
    373     if (mediaElement()->readyState() <= HTMLMediaElement::HAVE_METADATA && !mediaElement()->currentSrc().isEmpty())
     375    if (mediaController()->readyState() <= MediaControllerInterface::HAVE_METADATA && mediaController()->hasCurrentSrc())
    374376        newStateToDisplay = Loading;
    375     else if (mediaElement()->movieLoadType() == MediaPlayer::LiveStream)
     377    else if (mediaController()->isLiveStream())
    376378        newStateToDisplay = LiveBroadcast;
    377379
     
    414416// ----------------------------
    415417   
    416 MediaControlInputElement::MediaControlInputElement(HTMLMediaElement* mediaElement, MediaControlElementType displayType)
    417     : HTMLInputElement(inputTag, mediaElement->document(), 0, false)
    418     , m_mediaElement(mediaElement)
     418MediaControlInputElement::MediaControlInputElement(Document* document, MediaControlElementType displayType)
     419    : HTMLInputElement(inputTag, document, 0, false)
     420    , m_mediaController(0)
    419421    , m_displayType(displayType)
    420422{
     
    444446// ----------------------------
    445447
    446 inline MediaControlMuteButtonElement::MediaControlMuteButtonElement(HTMLMediaElement* mediaElement, MediaControlElementType displayType)
    447     : MediaControlInputElement(mediaElement, displayType)
     448inline MediaControlMuteButtonElement::MediaControlMuteButtonElement(Document* document, MediaControlElementType displayType)
     449    : MediaControlInputElement(document, displayType)
    448450{
    449451}
     
    452454{
    453455    if (event->type() == eventNames().clickEvent) {
    454         mediaElement()->setMuted(!mediaElement()->muted());
     456        mediaController()->setMuted(!mediaController()->muted());
    455457        event->setDefaultHandled();
    456458    }
     
    466468void MediaControlMuteButtonElement::updateDisplayType()
    467469{
    468     setDisplayType(mediaElement()->muted() ? MediaUnMuteButton : MediaMuteButton);
    469 }
    470 
    471 // ----------------------------
    472 
    473 inline MediaControlPanelMuteButtonElement::MediaControlPanelMuteButtonElement(HTMLMediaElement* mediaElement, MediaControls* controls)
    474     : MediaControlMuteButtonElement(mediaElement, MediaMuteButton)
     470    setDisplayType(mediaController()->muted() ? MediaUnMuteButton : MediaMuteButton);
     471}
     472
     473// ----------------------------
     474
     475inline MediaControlPanelMuteButtonElement::MediaControlPanelMuteButtonElement(Document* document, MediaControls* controls)
     476    : MediaControlMuteButtonElement(document, MediaMuteButton)
    475477    , m_controls(controls)
    476478{
    477479}
    478480
    479 PassRefPtr<MediaControlPanelMuteButtonElement> MediaControlPanelMuteButtonElement::create(HTMLMediaElement* mediaElement, MediaControls* controls)
     481PassRefPtr<MediaControlPanelMuteButtonElement> MediaControlPanelMuteButtonElement::create(Document* document, MediaControls* controls)
    480482{
    481483    ASSERT(controls);
    482484
    483     RefPtr<MediaControlPanelMuteButtonElement> button = adoptRef(new MediaControlPanelMuteButtonElement(mediaElement, controls));
     485    RefPtr<MediaControlPanelMuteButtonElement> button = adoptRef(new MediaControlPanelMuteButtonElement(document, controls));
    484486    button->setType("button");
    485487    return button.release();
     
    502504// ----------------------------
    503505
    504 inline MediaControlVolumeSliderMuteButtonElement::MediaControlVolumeSliderMuteButtonElement(HTMLMediaElement* mediaElement)
    505     : MediaControlMuteButtonElement(mediaElement, MediaMuteButton)
    506 {
    507 }
    508 
    509 PassRefPtr<MediaControlVolumeSliderMuteButtonElement> MediaControlVolumeSliderMuteButtonElement::create(HTMLMediaElement* mediaElement)
    510 {
    511     RefPtr<MediaControlVolumeSliderMuteButtonElement> button = adoptRef(new MediaControlVolumeSliderMuteButtonElement(mediaElement));
     506inline MediaControlVolumeSliderMuteButtonElement::MediaControlVolumeSliderMuteButtonElement(Document* document)
     507    : MediaControlMuteButtonElement(document, MediaMuteButton)
     508{
     509}
     510
     511PassRefPtr<MediaControlVolumeSliderMuteButtonElement> MediaControlVolumeSliderMuteButtonElement::create(Document* document)
     512{
     513    RefPtr<MediaControlVolumeSliderMuteButtonElement> button = adoptRef(new MediaControlVolumeSliderMuteButtonElement(document));
    512514    button->setType("button");
    513515    return button.release();
     
    522524// ----------------------------
    523525
    524 inline MediaControlPlayButtonElement::MediaControlPlayButtonElement(HTMLMediaElement* mediaElement)
    525     : MediaControlInputElement(mediaElement, MediaPlayButton)
    526 {
    527 }
    528 
    529 PassRefPtr<MediaControlPlayButtonElement> MediaControlPlayButtonElement::create(HTMLMediaElement* mediaElement)
    530 {
    531     RefPtr<MediaControlPlayButtonElement> button = adoptRef(new MediaControlPlayButtonElement(mediaElement));
     526inline MediaControlPlayButtonElement::MediaControlPlayButtonElement(Document* document)
     527    : MediaControlInputElement(document, MediaPlayButton)
     528{
     529}
     530
     531PassRefPtr<MediaControlPlayButtonElement> MediaControlPlayButtonElement::create(Document* document)
     532{
     533    RefPtr<MediaControlPlayButtonElement> button = adoptRef(new MediaControlPlayButtonElement(document));
    532534    button->setType("button");
    533535    return button.release();
     
    537539{
    538540    if (event->type() == eventNames().clickEvent) {
    539         mediaElement()->togglePlayState();
     541        if (mediaController()->canPlay())
     542            mediaController()->play();
     543        else
     544            mediaController()->pause();
    540545        updateDisplayType();
    541546        event->setDefaultHandled();
     
    546551void MediaControlPlayButtonElement::updateDisplayType()
    547552{
    548     setDisplayType(mediaElement()->canPlay() ? MediaPlayButton : MediaPauseButton);
     553    setDisplayType(mediaController()->canPlay() ? MediaPlayButton : MediaPauseButton);
    549554}
    550555
     
    557562// ----------------------------
    558563
    559 inline MediaControlSeekButtonElement::MediaControlSeekButtonElement(HTMLMediaElement* mediaElement, MediaControlElementType displayType)
    560     : MediaControlInputElement(mediaElement, displayType)
     564inline MediaControlSeekButtonElement::MediaControlSeekButtonElement(Document* document, MediaControlElementType displayType)
     565    : MediaControlInputElement(document, displayType)
    561566    , m_actionOnStop(Nothing)
    562567    , m_seekType(Skip)
     
    588593void MediaControlSeekButtonElement::startTimer()
    589594{
    590     m_seekType = mediaElement()->supportsScanning() ? Scan : Skip;
     595    m_seekType = mediaController()->supportsScanning() ? Scan : Skip;
    591596
    592597    if (m_seekType == Skip) {
    593598        // Seeking by skipping requires the video to be paused during seeking.
    594         m_actionOnStop = mediaElement()->isPlaying() ? Play : Nothing;
    595         mediaElement()->pause();
     599        m_actionOnStop = mediaController()->paused() ? Nothing : Play;
     600        mediaController()->pause();
    596601    } else {
    597602        // Seeking by scanning requires the video to be playing during seeking.
    598         m_actionOnStop = mediaElement()->paused() ? Pause : Nothing;
    599         mediaElement()->play();
    600         mediaElement()->setPlaybackRate(nextRate());
     603        m_actionOnStop = mediaController()->paused() ? Pause : Nothing;
     604        mediaController()->play();
     605        mediaController()->setPlaybackRate(nextRate());
    601606    }
    602607
     
    607612{
    608613    if (m_seekType == Scan)
    609         mediaElement()->setPlaybackRate(mediaElement()->defaultPlaybackRate());
     614        mediaController()->setPlaybackRate(mediaController()->defaultPlaybackRate());
    610615
    611616    if (m_actionOnStop == Play)
    612         mediaElement()->play();
     617        mediaController()->play();
    613618    else if (m_actionOnStop == Pause)
    614         mediaElement()->pause();
     619        mediaController()->pause();
    615620
    616621    if (m_seekTimer.isActive())
     
    620625float MediaControlSeekButtonElement::nextRate() const
    621626{
    622     float rate = std::min(cScanMaximumRate, fabsf(mediaElement()->playbackRate() * 2));
     627    float rate = std::min(cScanMaximumRate, fabsf(mediaController()->playbackRate() * 2));
    623628    if (!isForwardButton())
    624629        rate *= -1;
     
    631636        ExceptionCode ec;
    632637        float skipTime = isForwardButton() ? cSkipTime : -cSkipTime;
    633         mediaElement()->setCurrentTime(mediaElement()->currentTime() + skipTime, ec);
     638        mediaController()->setCurrentTime(mediaController()->currentTime() + skipTime, ec);
    634639    } else
    635         mediaElement()->setPlaybackRate(nextRate());
    636 }
    637 
    638 // ----------------------------
    639 
    640 inline MediaControlSeekForwardButtonElement::MediaControlSeekForwardButtonElement(HTMLMediaElement* mediaElement)
    641     : MediaControlSeekButtonElement(mediaElement, MediaSeekForwardButton)
    642 {
    643 }
    644 
    645 PassRefPtr<MediaControlSeekForwardButtonElement> MediaControlSeekForwardButtonElement::create(HTMLMediaElement* mediaElement)
    646 {
    647     RefPtr<MediaControlSeekForwardButtonElement> button = adoptRef(new MediaControlSeekForwardButtonElement(mediaElement));
     640        mediaController()->setPlaybackRate(nextRate());
     641}
     642
     643// ----------------------------
     644
     645inline MediaControlSeekForwardButtonElement::MediaControlSeekForwardButtonElement(Document* document)
     646    : MediaControlSeekButtonElement(document, MediaSeekForwardButton)
     647{
     648}
     649
     650PassRefPtr<MediaControlSeekForwardButtonElement> MediaControlSeekForwardButtonElement::create(Document* document)
     651{
     652    RefPtr<MediaControlSeekForwardButtonElement> button = adoptRef(new MediaControlSeekForwardButtonElement(document));
    648653    button->setType("button");
    649654    return button.release();
     
    658663// ----------------------------
    659664
    660 inline MediaControlSeekBackButtonElement::MediaControlSeekBackButtonElement(HTMLMediaElement* mediaElement)
    661     : MediaControlSeekButtonElement(mediaElement, MediaSeekBackButton)
    662 {
    663 }
    664 
    665 PassRefPtr<MediaControlSeekBackButtonElement> MediaControlSeekBackButtonElement::create(HTMLMediaElement* mediaElement)
    666 {
    667     RefPtr<MediaControlSeekBackButtonElement> button = adoptRef(new MediaControlSeekBackButtonElement(mediaElement));
     665inline MediaControlSeekBackButtonElement::MediaControlSeekBackButtonElement(Document* document)
     666    : MediaControlSeekButtonElement(document, MediaSeekBackButton)
     667{
     668}
     669
     670PassRefPtr<MediaControlSeekBackButtonElement> MediaControlSeekBackButtonElement::create(Document* document)
     671{
     672    RefPtr<MediaControlSeekBackButtonElement> button = adoptRef(new MediaControlSeekBackButtonElement(document));
    668673    button->setType("button");
    669674    return button.release();
     
    678683// ----------------------------
    679684
    680 inline MediaControlRewindButtonElement::MediaControlRewindButtonElement(HTMLMediaElement* element)
    681     : MediaControlInputElement(element, MediaRewindButton)
    682 {
    683 }
    684 
    685 PassRefPtr<MediaControlRewindButtonElement> MediaControlRewindButtonElement::create(HTMLMediaElement* mediaElement)
    686 {
    687     RefPtr<MediaControlRewindButtonElement> button = adoptRef(new MediaControlRewindButtonElement(mediaElement));
     685inline MediaControlRewindButtonElement::MediaControlRewindButtonElement(Document* document)
     686    : MediaControlInputElement(document, MediaRewindButton)
     687{
     688}
     689
     690PassRefPtr<MediaControlRewindButtonElement> MediaControlRewindButtonElement::create(Document* document)
     691{
     692    RefPtr<MediaControlRewindButtonElement> button = adoptRef(new MediaControlRewindButtonElement(document));
    688693    button->setType("button");
    689694    return button.release();
     
    693698{
    694699    if (event->type() == eventNames().clickEvent) {
    695         mediaElement()->rewind(30);
     700        ExceptionCode ignoredCode;
     701        mediaController()->setCurrentTime(max(0.0f, mediaController()->currentTime() - 30), ignoredCode);
    696702        event->setDefaultHandled();
    697703    }   
     
    707713// ----------------------------
    708714
    709 inline MediaControlReturnToRealtimeButtonElement::MediaControlReturnToRealtimeButtonElement(HTMLMediaElement* mediaElement)
    710     : MediaControlInputElement(mediaElement, MediaReturnToRealtimeButton)
    711 {
    712 }
    713 
    714 PassRefPtr<MediaControlReturnToRealtimeButtonElement> MediaControlReturnToRealtimeButtonElement::create(HTMLMediaElement* mediaElement)
    715 {
    716     RefPtr<MediaControlReturnToRealtimeButtonElement> button = adoptRef(new MediaControlReturnToRealtimeButtonElement(mediaElement));
     715inline MediaControlReturnToRealtimeButtonElement::MediaControlReturnToRealtimeButtonElement(Document* document)
     716    : MediaControlInputElement(document, MediaReturnToRealtimeButton)
     717{
     718}
     719
     720PassRefPtr<MediaControlReturnToRealtimeButtonElement> MediaControlReturnToRealtimeButtonElement::create(Document* document)
     721{
     722    RefPtr<MediaControlReturnToRealtimeButtonElement> button = adoptRef(new MediaControlReturnToRealtimeButtonElement(document));
    717723    button->setType("button");
    718724    button->hide();
     
    723729{
    724730    if (event->type() == eventNames().clickEvent) {
    725         mediaElement()->returnToRealtime();
     731        mediaController()->returnToRealtime();
    726732        event->setDefaultHandled();
    727733    }
     
    737743// ----------------------------
    738744
    739 inline MediaControlToggleClosedCaptionsButtonElement::MediaControlToggleClosedCaptionsButtonElement(HTMLMediaElement* mediaElement)
    740     : MediaControlInputElement(mediaElement, MediaShowClosedCaptionsButton)
    741 {
    742 }
    743 
    744 PassRefPtr<MediaControlToggleClosedCaptionsButtonElement> MediaControlToggleClosedCaptionsButtonElement::create(HTMLMediaElement* mediaElement)
    745 {
    746     RefPtr<MediaControlToggleClosedCaptionsButtonElement> button = adoptRef(new MediaControlToggleClosedCaptionsButtonElement(mediaElement));
     745inline MediaControlToggleClosedCaptionsButtonElement::MediaControlToggleClosedCaptionsButtonElement(Document* document)
     746    : MediaControlInputElement(document, MediaShowClosedCaptionsButton)
     747{
     748}
     749
     750PassRefPtr<MediaControlToggleClosedCaptionsButtonElement> MediaControlToggleClosedCaptionsButtonElement::create(Document* document)
     751{
     752    RefPtr<MediaControlToggleClosedCaptionsButtonElement> button = adoptRef(new MediaControlToggleClosedCaptionsButtonElement(document));
    747753    button->setType("button");
    748754    button->hide();
     
    753759{
    754760    if (event->type() == eventNames().clickEvent) {
    755         mediaElement()->setClosedCaptionsVisible(!mediaElement()->closedCaptionsVisible());
    756         setChecked(mediaElement()->closedCaptionsVisible());
     761        mediaController()->setClosedCaptionsVisible(!mediaController()->closedCaptionsVisible());
     762        setChecked(mediaController()->closedCaptionsVisible());
    757763        updateDisplayType();
    758764        event->setDefaultHandled();
     
    764770void MediaControlToggleClosedCaptionsButtonElement::updateDisplayType()
    765771{
    766     setDisplayType(mediaElement()->closedCaptionsVisible() ? MediaHideClosedCaptionsButton : MediaShowClosedCaptionsButton);
     772    setDisplayType(mediaController()->closedCaptionsVisible() ? MediaHideClosedCaptionsButton : MediaShowClosedCaptionsButton);
    767773}
    768774
     
    775781// ----------------------------
    776782
    777 MediaControlTimelineElement::MediaControlTimelineElement(HTMLMediaElement* mediaElement, MediaControls* controls)
    778     : MediaControlInputElement(mediaElement, MediaSlider)
     783MediaControlTimelineElement::MediaControlTimelineElement(Document* document, MediaControls* controls)
     784    : MediaControlInputElement(document, MediaSlider)
    779785    , m_controls(controls)
    780786{
    781787}
    782788
    783 PassRefPtr<MediaControlTimelineElement> MediaControlTimelineElement::create(HTMLMediaElement* mediaElement, MediaControls* controls)
     789PassRefPtr<MediaControlTimelineElement> MediaControlTimelineElement::create(Document* document, MediaControls* controls)
    784790{
    785791    ASSERT(controls);
    786792
    787     RefPtr<MediaControlTimelineElement> timeline = adoptRef(new MediaControlTimelineElement(mediaElement, controls));
     793    RefPtr<MediaControlTimelineElement> timeline = adoptRef(new MediaControlTimelineElement(document, controls));
    788794    timeline->setType("range");
    789795    timeline->setAttribute(precisionAttr, "float");
     
    801807
    802808    if (event->type() == eventNames().mousedownEvent)
    803         mediaElement()->beginScrubbing();
     809        mediaController()->beginScrubbing();
    804810
    805811    if (event->type() == eventNames().mouseupEvent)
    806         mediaElement()->endScrubbing();
     812        mediaController()->endScrubbing();
    807813
    808814    MediaControlInputElement::defaultEventHandler(event);
     
    812818
    813819    float time = narrowPrecisionToFloat(value().toDouble());
    814     if (time != mediaElement()->currentTime()) {
     820    if (time != mediaController()->currentTime()) {
    815821        // FIXME: This is fired 3 times on every click. We should not be doing that <http:/webkit.org/b/58160>.
    816822        ExceptionCode ec;
    817         mediaElement()->setCurrentTime(time, ec);
     823        mediaController()->setCurrentTime(time, ec);
    818824    }
    819825
     
    842848// ----------------------------
    843849
    844 inline MediaControlVolumeSliderElement::MediaControlVolumeSliderElement(HTMLMediaElement* mediaElement)
    845     : MediaControlInputElement(mediaElement, MediaVolumeSlider)
    846 {
    847 }
    848 
    849 PassRefPtr<MediaControlVolumeSliderElement> MediaControlVolumeSliderElement::create(HTMLMediaElement* mediaElement)
    850 {
    851     RefPtr<MediaControlVolumeSliderElement> slider = adoptRef(new MediaControlVolumeSliderElement(mediaElement));
     850inline MediaControlVolumeSliderElement::MediaControlVolumeSliderElement(Document* document)
     851    : MediaControlInputElement(document, MediaVolumeSlider)
     852{
     853}
     854
     855PassRefPtr<MediaControlVolumeSliderElement> MediaControlVolumeSliderElement::create(Document* document)
     856{
     857    RefPtr<MediaControlVolumeSliderElement> slider = adoptRef(new MediaControlVolumeSliderElement(document));
    852858    slider->setType("range");
    853859    slider->setAttribute(precisionAttr, "float");
    854860    slider->setAttribute(maxAttr, "1");
    855     slider->setAttribute(valueAttr, String::number(mediaElement->volume()));
    856861    return slider.release();
    857862}
     
    872877
    873878    float volume = narrowPrecisionToFloat(value().toDouble());
    874     if (volume != mediaElement()->volume()) {
     879    if (volume != mediaController()->volume()) {
    875880        ExceptionCode ec = 0;
    876         mediaElement()->setVolume(volume, ec);
     881        mediaController()->setVolume(volume, ec);
    877882        ASSERT(!ec);
    878883    }
     
    893898// ----------------------------
    894899
    895 inline MediaControlFullscreenVolumeSliderElement::MediaControlFullscreenVolumeSliderElement(HTMLMediaElement* mediaElement)
    896     : MediaControlVolumeSliderElement(mediaElement)
    897 {
    898 }
    899 
    900 PassRefPtr<MediaControlFullscreenVolumeSliderElement> MediaControlFullscreenVolumeSliderElement::create(HTMLMediaElement* mediaElement)
    901 {
    902     RefPtr<MediaControlFullscreenVolumeSliderElement> slider = adoptRef(new MediaControlFullscreenVolumeSliderElement(mediaElement));
     900inline MediaControlFullscreenVolumeSliderElement::MediaControlFullscreenVolumeSliderElement(Document* document)
     901    : MediaControlVolumeSliderElement(document)
     902{
     903}
     904
     905PassRefPtr<MediaControlFullscreenVolumeSliderElement> MediaControlFullscreenVolumeSliderElement::create(Document* document)
     906{
     907    RefPtr<MediaControlFullscreenVolumeSliderElement> slider = adoptRef(new MediaControlFullscreenVolumeSliderElement(document));
    903908    slider->setType("range");
    904909    slider->setAttribute(precisionAttr, "float");
    905910    slider->setAttribute(maxAttr, "1");
    906     slider->setAttribute(valueAttr, String::number(mediaElement->volume()));
    907911    return slider.release();
    908912}
     
    916920// ----------------------------
    917921
    918 inline MediaControlFullscreenButtonElement::MediaControlFullscreenButtonElement(HTMLMediaElement* mediaElement, MediaControls* controls)
    919     : MediaControlInputElement(mediaElement, MediaFullscreenButton)
     922inline MediaControlFullscreenButtonElement::MediaControlFullscreenButtonElement(Document* document, MediaControls* controls)
     923    : MediaControlInputElement(document, MediaFullscreenButton)
    920924    , m_controls(controls)
    921925{
    922926}
    923927
    924 PassRefPtr<MediaControlFullscreenButtonElement> MediaControlFullscreenButtonElement::create(HTMLMediaElement* mediaElement, MediaControls* controls)
     928PassRefPtr<MediaControlFullscreenButtonElement> MediaControlFullscreenButtonElement::create(Document* document, MediaControls* controls)
    925929{
    926930    ASSERT(controls);
    927931
    928     RefPtr<MediaControlFullscreenButtonElement> button = adoptRef(new MediaControlFullscreenButtonElement(mediaElement, controls));
     932    RefPtr<MediaControlFullscreenButtonElement> button = adoptRef(new MediaControlFullscreenButtonElement(document, controls));
    929933    button->setType("button");
    930934    button->hide();
     
    942946        // screen behavior.
    943947        if (document()->settings() && document()->settings()->fullScreenEnabled()) {
    944             if (document()->webkitIsFullScreen() && document()->webkitCurrentFullScreenElement() == mediaElement())
     948            if (document()->webkitIsFullScreen() && document()->webkitCurrentFullScreenElement() == toParentMediaElement(this))
    945949                document()->webkitCancelFullScreen();
    946950            else
    947                 document()->requestFullScreenForElement(mediaElement(), 0, Document::ExemptIFrameAllowFulScreenRequirement);
     951                document()->requestFullScreenForElement(toParentMediaElement(this), 0, Document::ExemptIFrameAllowFulScreenRequirement);
    948952        } else
    949953#endif
    950             mediaElement()->enterFullscreen();
     954            mediaController()->enterFullscreen();
    951955        event->setDefaultHandled();
    952956    }
     
    962966// ----------------------------
    963967
    964 inline MediaControlFullscreenVolumeMinButtonElement::MediaControlFullscreenVolumeMinButtonElement(HTMLMediaElement* mediaElement)
    965     : MediaControlInputElement(mediaElement, MediaUnMuteButton)
    966 {
    967 }
    968 
    969 PassRefPtr<MediaControlFullscreenVolumeMinButtonElement> MediaControlFullscreenVolumeMinButtonElement::create(HTMLMediaElement* mediaElement)
    970 {
    971     RefPtr<MediaControlFullscreenVolumeMinButtonElement> button = adoptRef(new MediaControlFullscreenVolumeMinButtonElement(mediaElement));
     968inline MediaControlFullscreenVolumeMinButtonElement::MediaControlFullscreenVolumeMinButtonElement(Document* document)
     969    : MediaControlInputElement(document, MediaUnMuteButton)
     970{
     971}
     972
     973PassRefPtr<MediaControlFullscreenVolumeMinButtonElement> MediaControlFullscreenVolumeMinButtonElement::create(Document* document)
     974{
     975    RefPtr<MediaControlFullscreenVolumeMinButtonElement> button = adoptRef(new MediaControlFullscreenVolumeMinButtonElement(document));
    972976    button->setType("button");
    973977    return button.release();
     
    978982    if (event->type() == eventNames().clickEvent) {
    979983        ExceptionCode code = 0;
    980         mediaElement()->setVolume(0, code);
     984        mediaController()->setVolume(0, code);
    981985        event->setDefaultHandled();
    982986    }
     
    992996// ----------------------------
    993997
    994 inline MediaControlFullscreenVolumeMaxButtonElement::MediaControlFullscreenVolumeMaxButtonElement(HTMLMediaElement* mediaElement)
    995 : MediaControlInputElement(mediaElement, MediaMuteButton)
    996 {
    997 }
    998 
    999 PassRefPtr<MediaControlFullscreenVolumeMaxButtonElement> MediaControlFullscreenVolumeMaxButtonElement::create(HTMLMediaElement* mediaElement)
    1000 {
    1001     RefPtr<MediaControlFullscreenVolumeMaxButtonElement> button = adoptRef(new MediaControlFullscreenVolumeMaxButtonElement(mediaElement));
     998inline MediaControlFullscreenVolumeMaxButtonElement::MediaControlFullscreenVolumeMaxButtonElement(Document* document)
     999: MediaControlInputElement(document, MediaMuteButton)
     1000{
     1001}
     1002
     1003PassRefPtr<MediaControlFullscreenVolumeMaxButtonElement> MediaControlFullscreenVolumeMaxButtonElement::create(Document* document)
     1004{
     1005    RefPtr<MediaControlFullscreenVolumeMaxButtonElement> button = adoptRef(new MediaControlFullscreenVolumeMaxButtonElement(document));
    10021006    button->setType("button");
    10031007    return button.release();
     
    10081012    if (event->type() == eventNames().clickEvent) {
    10091013        ExceptionCode code = 0;
    1010         mediaElement()->setVolume(1, code);
     1014        mediaController()->setVolume(1, code);
    10111015        event->setDefaultHandled();
    10121016    }
     
    10501054}
    10511055
    1052 inline MediaControlTimeDisplayElement::MediaControlTimeDisplayElement(HTMLMediaElement* mediaElement)
    1053     : MediaControlElement(mediaElement)
     1056inline MediaControlTimeDisplayElement::MediaControlTimeDisplayElement(Document* document)
     1057    : MediaControlElement(document)
    10541058    , m_currentValue(0)
    10551059{
     
    10681072// ----------------------------
    10691073
    1070 PassRefPtr<MediaControlTimeRemainingDisplayElement> MediaControlTimeRemainingDisplayElement::create(HTMLMediaElement* mediaElement)
    1071 {
    1072     return adoptRef(new MediaControlTimeRemainingDisplayElement(mediaElement));
    1073 }
    1074 
    1075 MediaControlTimeRemainingDisplayElement::MediaControlTimeRemainingDisplayElement(HTMLMediaElement* mediaElement)
    1076     : MediaControlTimeDisplayElement(mediaElement)
     1074PassRefPtr<MediaControlTimeRemainingDisplayElement> MediaControlTimeRemainingDisplayElement::create(Document* document)
     1075{
     1076    return adoptRef(new MediaControlTimeRemainingDisplayElement(document));
     1077}
     1078
     1079MediaControlTimeRemainingDisplayElement::MediaControlTimeRemainingDisplayElement(Document* document)
     1080    : MediaControlTimeDisplayElement(document)
    10771081{
    10781082}
     
    10911095// ----------------------------
    10921096
    1093 PassRefPtr<MediaControlCurrentTimeDisplayElement> MediaControlCurrentTimeDisplayElement::create(HTMLMediaElement* mediaElement)
    1094 {
    1095     return adoptRef(new MediaControlCurrentTimeDisplayElement(mediaElement));
    1096 }
    1097 
    1098 MediaControlCurrentTimeDisplayElement::MediaControlCurrentTimeDisplayElement(HTMLMediaElement* mediaElement)
    1099     : MediaControlTimeDisplayElement(mediaElement)
     1097PassRefPtr<MediaControlCurrentTimeDisplayElement> MediaControlCurrentTimeDisplayElement::create(Document* document)
     1098{
     1099    return adoptRef(new MediaControlCurrentTimeDisplayElement(document));
     1100}
     1101
     1102MediaControlCurrentTimeDisplayElement::MediaControlCurrentTimeDisplayElement(Document* document)
     1103    : MediaControlTimeDisplayElement(document)
    11001104{
    11011105}
  • trunk/Source/WebCore/html/shadow/MediaControlElements.h

    r100408 r101810  
    3434#include "HTMLDivElement.h"
    3535#include "HTMLInputElement.h"
    36 #include "HTMLMediaElement.h"
     36#include "MediaControllerInterface.h"
    3737#include "RenderBlock.h"
    3838
     
    4343class Event;
    4444class Frame;
     45class HTMLMediaElement;
    4546class MediaControls;
    4647
     
    8586    virtual MediaControlElementType displayType() const = 0;
    8687
    87     HTMLMediaElement* mediaElement() const { return m_mediaElement; }
    88 
    89 protected:
    90     MediaControlElement(HTMLMediaElement*);
     88    void setMediaController(MediaControllerInterface* controller) { m_mediaController = controller; }
     89    MediaControllerInterface* mediaController() const { return m_mediaController; }
     90
     91protected:
     92    MediaControlElement(Document*);
    9193
    9294private:
    9395    virtual bool isMediaControlElement() const { return true; }
    9496
    95     HTMLMediaElement* m_mediaElement;   
     97    MediaControllerInterface* m_mediaController;   
    9698};
    9799
     
    100102class MediaControlPanelElement : public MediaControlElement {
    101103public:
    102     static PassRefPtr<MediaControlPanelElement> create(HTMLMediaElement*);
     104    static PassRefPtr<MediaControlPanelElement> create(Document*);
    103105
    104106    void setCanBeDragged(bool);
     
    108110
    109111private:
    110     MediaControlPanelElement(HTMLMediaElement*);
     112    MediaControlPanelElement(Document*);
    111113    virtual MediaControlElementType displayType() const;
    112114    virtual const AtomicString& shadowPseudoId() const;
     
    130132class MediaControlTimelineContainerElement : public MediaControlElement {
    131133public:
    132     static PassRefPtr<MediaControlTimelineContainerElement> create(HTMLMediaElement*);
    133 
    134 private:
    135     MediaControlTimelineContainerElement(HTMLMediaElement*);
     134    static PassRefPtr<MediaControlTimelineContainerElement> create(Document*);
     135
     136private:
     137    MediaControlTimelineContainerElement(Document*);
    136138    virtual const AtomicString& shadowPseudoId() const;
    137139
     
    143145class MediaControlVolumeSliderContainerElement : public MediaControlElement {
    144146public:
    145     static PassRefPtr<MediaControlVolumeSliderContainerElement> create(HTMLMediaElement*);
    146 
    147 private:
    148     MediaControlVolumeSliderContainerElement(HTMLMediaElement*);
     147    static PassRefPtr<MediaControlVolumeSliderContainerElement> create(Document*);
     148
     149private:
     150    MediaControlVolumeSliderContainerElement(Document*);
    149151    virtual RenderObject* createRenderer(RenderArena*, RenderStyle*);
    150152    virtual void defaultEventHandler(Event*);
     
    157159class MediaControlStatusDisplayElement : public MediaControlElement {
    158160public:
    159     static PassRefPtr<MediaControlStatusDisplayElement> create(HTMLMediaElement*);
     161    static PassRefPtr<MediaControlStatusDisplayElement> create(Document*);
    160162
    161163    void update();
    162164
    163165private:
    164     MediaControlStatusDisplayElement(HTMLMediaElement*);
     166    MediaControlStatusDisplayElement(Document*);
    165167
    166168    virtual MediaControlElementType displayType() const;
     
    180182    MediaControlElementType displayType() const { return m_displayType; }
    181183
    182     HTMLMediaElement* mediaElement() const { return m_mediaElement; }
    183 
    184 protected:
    185     MediaControlInputElement(HTMLMediaElement*, MediaControlElementType);
     184    void setMediaController(MediaControllerInterface* controller) { m_mediaController = controller; }
     185    MediaControllerInterface* mediaController() const { return m_mediaController; }
     186
     187protected:
     188    MediaControlInputElement(Document*, MediaControlElementType);
    186189
    187190    void setDisplayType(MediaControlElementType);
     
    192195    virtual void updateDisplayType() { }
    193196
    194     HTMLMediaElement* m_mediaElement;
     197    MediaControllerInterface* m_mediaController;
    195198    MediaControlElementType m_displayType;
    196199};
     
    203206
    204207protected:
    205     MediaControlMuteButtonElement(HTMLMediaElement*, MediaControlElementType);
     208    MediaControlMuteButtonElement(Document*, MediaControlElementType);
    206209    virtual void defaultEventHandler(Event*);
    207210
     
    215218class MediaControlPanelMuteButtonElement : public MediaControlMuteButtonElement {
    216219public:
    217     static PassRefPtr<MediaControlPanelMuteButtonElement> create(HTMLMediaElement*, MediaControls*);
    218 
    219 private:
    220     MediaControlPanelMuteButtonElement(HTMLMediaElement*, MediaControls*);
     220    static PassRefPtr<MediaControlPanelMuteButtonElement> create(Document*, MediaControls*);
     221
     222private:
     223    MediaControlPanelMuteButtonElement(Document*, MediaControls*);
    221224
    222225    virtual void defaultEventHandler(Event*);
     
    230233class MediaControlVolumeSliderMuteButtonElement : public MediaControlMuteButtonElement {
    231234public:
    232     static PassRefPtr<MediaControlVolumeSliderMuteButtonElement> create(HTMLMediaElement*);
    233 
    234 private:
    235     MediaControlVolumeSliderMuteButtonElement(HTMLMediaElement*);
     235    static PassRefPtr<MediaControlVolumeSliderMuteButtonElement> create(Document*);
     236
     237private:
     238    MediaControlVolumeSliderMuteButtonElement(Document*);
    236239
    237240    virtual const AtomicString& shadowPseudoId() const;
     
    243246class MediaControlPlayButtonElement : public MediaControlInputElement {
    244247public:
    245     static PassRefPtr<MediaControlPlayButtonElement> create(HTMLMediaElement*);
     248    static PassRefPtr<MediaControlPlayButtonElement> create(Document*);
    246249
    247250    virtual void defaultEventHandler(Event*);
     
    249252
    250253private:
    251     MediaControlPlayButtonElement(HTMLMediaElement*);
     254    MediaControlPlayButtonElement(Document*);
    252255
    253256    virtual const AtomicString& shadowPseudoId() const;
     
    261264
    262265protected:
    263     MediaControlSeekButtonElement(HTMLMediaElement*, MediaControlElementType);
     266    MediaControlSeekButtonElement(Document*, MediaControlElementType);
    264267
    265268private:
     
    283286class MediaControlSeekForwardButtonElement : public MediaControlSeekButtonElement {
    284287public:
    285     static PassRefPtr<MediaControlSeekForwardButtonElement> create(HTMLMediaElement*);
    286 
    287 private:
    288     MediaControlSeekForwardButtonElement(HTMLMediaElement*);
     288    static PassRefPtr<MediaControlSeekForwardButtonElement> create(Document*);
     289
     290private:
     291    MediaControlSeekForwardButtonElement(Document*);
    289292
    290293    virtual bool isForwardButton() const { return true; }
     
    296299class MediaControlSeekBackButtonElement : public MediaControlSeekButtonElement {
    297300public:
    298     static PassRefPtr<MediaControlSeekBackButtonElement> create(HTMLMediaElement*);
    299 
    300 private:
    301     MediaControlSeekBackButtonElement(HTMLMediaElement*);
     301    static PassRefPtr<MediaControlSeekBackButtonElement> create(Document*);
     302
     303private:
     304    MediaControlSeekBackButtonElement(Document*);
    302305
    303306    virtual bool isForwardButton() const { return false; }
     
    309312class MediaControlRewindButtonElement : public MediaControlInputElement {
    310313public:
    311     static PassRefPtr<MediaControlRewindButtonElement> create(HTMLMediaElement*);
    312 
    313     virtual void defaultEventHandler(Event*);
    314 
    315 private:
    316     MediaControlRewindButtonElement(HTMLMediaElement*);
     314    static PassRefPtr<MediaControlRewindButtonElement> create(Document*);
     315
     316    virtual void defaultEventHandler(Event*);
     317
     318private:
     319    MediaControlRewindButtonElement(Document*);
    317320
    318321    virtual const AtomicString& shadowPseudoId() const;
     
    323326class MediaControlReturnToRealtimeButtonElement : public MediaControlInputElement {
    324327public:
    325     static PassRefPtr<MediaControlReturnToRealtimeButtonElement> create(HTMLMediaElement*);
    326 
    327     virtual void defaultEventHandler(Event*);
    328 
    329 private:
    330     MediaControlReturnToRealtimeButtonElement(HTMLMediaElement*);
     328    static PassRefPtr<MediaControlReturnToRealtimeButtonElement> create(Document*);
     329
     330    virtual void defaultEventHandler(Event*);
     331
     332private:
     333    MediaControlReturnToRealtimeButtonElement(Document*);
    331334
    332335    virtual const AtomicString& shadowPseudoId() const;
     
    337340class MediaControlToggleClosedCaptionsButtonElement : public MediaControlInputElement {
    338341public:
    339     static PassRefPtr<MediaControlToggleClosedCaptionsButtonElement> create(HTMLMediaElement*);
     342    static PassRefPtr<MediaControlToggleClosedCaptionsButtonElement> create(Document*);
    340343
    341344    virtual void defaultEventHandler(Event*);
     
    343346
    344347private:
    345     MediaControlToggleClosedCaptionsButtonElement(HTMLMediaElement*);
     348    MediaControlToggleClosedCaptionsButtonElement(Document*);
    346349
    347350    virtual const AtomicString& shadowPseudoId() const;
     
    352355class MediaControlTimelineElement : public MediaControlInputElement {
    353356public:
    354     static PassRefPtr<MediaControlTimelineElement> create(HTMLMediaElement*, MediaControls*);
     357    static PassRefPtr<MediaControlTimelineElement> create(Document*, MediaControls*);
    355358
    356359    virtual void defaultEventHandler(Event*);
     
    359362
    360363private:
    361     MediaControlTimelineElement(HTMLMediaElement*, MediaControls*);
     364    MediaControlTimelineElement(Document*, MediaControls*);
    362365
    363366    virtual const AtomicString& shadowPseudoId() const;
     
    370373class MediaControlVolumeSliderElement : public MediaControlInputElement {
    371374public:
    372     static PassRefPtr<MediaControlVolumeSliderElement> create(HTMLMediaElement*);
     375    static PassRefPtr<MediaControlVolumeSliderElement> create(Document*);
    373376
    374377    virtual void defaultEventHandler(Event*);
     
    376379
    377380protected:
    378     MediaControlVolumeSliderElement(HTMLMediaElement*);
     381    MediaControlVolumeSliderElement(Document*);
    379382
    380383private:
     
    386389class MediaControlFullscreenButtonElement : public MediaControlInputElement {
    387390public:
    388     static PassRefPtr<MediaControlFullscreenButtonElement> create(HTMLMediaElement*, MediaControls*);
    389 
    390     virtual void defaultEventHandler(Event*);
    391 
    392 private:
    393     MediaControlFullscreenButtonElement(HTMLMediaElement*, MediaControls*);
     391    static PassRefPtr<MediaControlFullscreenButtonElement> create(Document*, MediaControls*);
     392
     393    virtual void defaultEventHandler(Event*);
     394
     395private:
     396    MediaControlFullscreenButtonElement(Document*, MediaControls*);
    394397
    395398    virtual const AtomicString& shadowPseudoId() const;
     
    402405class MediaControlFullscreenVolumeSliderElement : public MediaControlVolumeSliderElement {
    403406public:
    404     static PassRefPtr<MediaControlFullscreenVolumeSliderElement> create(HTMLMediaElement*);
    405    
    406 private:
    407     MediaControlFullscreenVolumeSliderElement(HTMLMediaElement*);
     407    static PassRefPtr<MediaControlFullscreenVolumeSliderElement> create(Document*);
     408   
     409private:
     410    MediaControlFullscreenVolumeSliderElement(Document*);
    408411   
    409412    virtual const AtomicString& shadowPseudoId() const;
     
    414417class MediaControlFullscreenVolumeMinButtonElement : public MediaControlInputElement {
    415418public:
    416     static PassRefPtr<MediaControlFullscreenVolumeMinButtonElement> create(HTMLMediaElement*);
    417    
    418     virtual void defaultEventHandler(Event*);
    419    
    420 private:
    421     MediaControlFullscreenVolumeMinButtonElement(HTMLMediaElement*);
     419    static PassRefPtr<MediaControlFullscreenVolumeMinButtonElement> create(Document*);
     420   
     421    virtual void defaultEventHandler(Event*);
     422   
     423private:
     424    MediaControlFullscreenVolumeMinButtonElement(Document*);
    422425   
    423426    virtual const AtomicString& shadowPseudoId() const;
     
    428431class MediaControlFullscreenVolumeMaxButtonElement : public MediaControlInputElement {
    429432public:
    430     static PassRefPtr<MediaControlFullscreenVolumeMaxButtonElement> create(HTMLMediaElement*);
    431    
    432     virtual void defaultEventHandler(Event*);
    433    
    434 private:
    435     MediaControlFullscreenVolumeMaxButtonElement(HTMLMediaElement*);
     433    static PassRefPtr<MediaControlFullscreenVolumeMaxButtonElement> create(Document*);
     434   
     435    virtual void defaultEventHandler(Event*);
     436   
     437private:
     438    MediaControlFullscreenVolumeMaxButtonElement(Document*);
    436439   
    437440    virtual const AtomicString& shadowPseudoId() const;
     
    446449
    447450protected:
    448     MediaControlTimeDisplayElement(HTMLMediaElement*);
     451    MediaControlTimeDisplayElement(Document*);
    449452
    450453private:
     
    458461class MediaControlTimeRemainingDisplayElement : public MediaControlTimeDisplayElement {
    459462public:
    460     static PassRefPtr<MediaControlTimeRemainingDisplayElement> create(HTMLMediaElement*);
    461 
    462 private:
    463     MediaControlTimeRemainingDisplayElement(HTMLMediaElement*);
     463    static PassRefPtr<MediaControlTimeRemainingDisplayElement> create(Document*);
     464
     465private:
     466    MediaControlTimeRemainingDisplayElement(Document*);
    464467
    465468    virtual MediaControlElementType displayType() const;
     
    471474class MediaControlCurrentTimeDisplayElement : public MediaControlTimeDisplayElement {
    472475public:
    473     static PassRefPtr<MediaControlCurrentTimeDisplayElement> create(HTMLMediaElement*);
    474 
    475 private:
    476     MediaControlCurrentTimeDisplayElement(HTMLMediaElement*);
     476    static PassRefPtr<MediaControlCurrentTimeDisplayElement> create(Document*);
     477
     478private:
     479    MediaControlCurrentTimeDisplayElement(Document*);
    477480
    478481    virtual MediaControlElementType displayType() const;
  • trunk/Source/WebCore/html/shadow/MediaControlRootElement.cpp

    r97157 r101810  
    3131
    3232#include "Chrome.h"
     33#include "HTMLMediaElement.h"
    3334#include "MediaControlElements.h"
    3435#include "MouseEvent.h"
     
    4243static const double timeWithoutMouseMovementBeforeHidingControls = 3;
    4344
    44 MediaControlRootElement::MediaControlRootElement(HTMLMediaElement* mediaElement)
    45     : MediaControls(mediaElement)
    46     , m_mediaElement(mediaElement)
     45MediaControlRootElement::MediaControlRootElement(Document* document)
     46    : MediaControls(document)
     47    , m_mediaController(0)
    4748    , m_rewindButton(0)
    4849    , m_playButton(0)
     
    7071}
    7172
    72 PassRefPtr<MediaControls> MediaControls::create(HTMLMediaElement* mediaElement)
    73 {
    74     return MediaControlRootElement::create(mediaElement);
    75 }
    76 
    77 PassRefPtr<MediaControlRootElement> MediaControlRootElement::create(HTMLMediaElement* mediaElement)
    78 {
    79     if (!mediaElement->document()->page())
    80         return 0;
    81 
    82     RefPtr<MediaControlRootElement> controls = adoptRef(new MediaControlRootElement(mediaElement));
    83 
    84     RefPtr<MediaControlPanelElement> panel = MediaControlPanelElement::create(mediaElement);
     73PassRefPtr<MediaControls> MediaControls::create(Document* document)
     74{
     75    return MediaControlRootElement::create(document);
     76}
     77
     78PassRefPtr<MediaControlRootElement> MediaControlRootElement::create(Document* document)
     79{
     80    if (!document->page())
     81        return 0;
     82
     83    RefPtr<MediaControlRootElement> controls = adoptRef(new MediaControlRootElement(document));
     84
     85    RefPtr<MediaControlPanelElement> panel = MediaControlPanelElement::create(document);
    8586
    8687    ExceptionCode ec;
    8788
    88     RefPtr<MediaControlRewindButtonElement> rewindButton = MediaControlRewindButtonElement::create(mediaElement);
     89    RefPtr<MediaControlRewindButtonElement> rewindButton = MediaControlRewindButtonElement::create(document);
    8990    controls->m_rewindButton = rewindButton.get();
    9091    panel->appendChild(rewindButton.release(), ec, true);
     
    9293        return 0;
    9394
    94     RefPtr<MediaControlPlayButtonElement> playButton = MediaControlPlayButtonElement::create(mediaElement);
     95    RefPtr<MediaControlPlayButtonElement> playButton = MediaControlPlayButtonElement::create(document);
    9596    controls->m_playButton = playButton.get();
    9697    panel->appendChild(playButton.release(), ec, true);
     
    9899        return 0;
    99100
    100     RefPtr<MediaControlReturnToRealtimeButtonElement> returnToRealtimeButton = MediaControlReturnToRealtimeButtonElement::create(mediaElement);
     101    RefPtr<MediaControlReturnToRealtimeButtonElement> returnToRealtimeButton = MediaControlReturnToRealtimeButtonElement::create(document);
    101102    controls->m_returnToRealTimeButton = returnToRealtimeButton.get();
    102103    panel->appendChild(returnToRealtimeButton.release(), ec, true);
     
    104105        return 0;
    105106
    106     if (mediaElement->document()->page()->theme()->usesMediaControlStatusDisplay()) {
    107         RefPtr<MediaControlStatusDisplayElement> statusDisplay = MediaControlStatusDisplayElement::create(mediaElement);
     107    if (document->page()->theme()->usesMediaControlStatusDisplay()) {
     108        RefPtr<MediaControlStatusDisplayElement> statusDisplay = MediaControlStatusDisplayElement::create(document);
    108109        controls->m_statusDisplay = statusDisplay.get();
    109110        panel->appendChild(statusDisplay.release(), ec, true);
     
    112113    }
    113114
    114     RefPtr<MediaControlTimelineContainerElement> timelineContainer = MediaControlTimelineContainerElement::create(mediaElement);
    115 
    116     RefPtr<MediaControlCurrentTimeDisplayElement> currentTimeDisplay = MediaControlCurrentTimeDisplayElement::create(mediaElement);
     115    RefPtr<MediaControlTimelineContainerElement> timelineContainer = MediaControlTimelineContainerElement::create(document);
     116
     117    RefPtr<MediaControlCurrentTimeDisplayElement> currentTimeDisplay = MediaControlCurrentTimeDisplayElement::create(document);
    117118    controls->m_currentTimeDisplay = currentTimeDisplay.get();
    118119    timelineContainer->appendChild(currentTimeDisplay.release(), ec, true);
     
    120121        return 0;
    121122
    122     RefPtr<MediaControlTimelineElement> timeline = MediaControlTimelineElement::create(mediaElement, controls.get());
     123    RefPtr<MediaControlTimelineElement> timeline = MediaControlTimelineElement::create(document, controls.get());
    123124    controls->m_timeline = timeline.get();
    124125    timelineContainer->appendChild(timeline.release(), ec, true);
     
    126127        return 0;
    127128
    128     RefPtr<MediaControlTimeRemainingDisplayElement> timeRemainingDisplay = MediaControlTimeRemainingDisplayElement::create(mediaElement);
     129    RefPtr<MediaControlTimeRemainingDisplayElement> timeRemainingDisplay = MediaControlTimeRemainingDisplayElement::create(document);
    129130    controls->m_timeRemainingDisplay = timeRemainingDisplay.get();
    130131    timelineContainer->appendChild(timeRemainingDisplay.release(), ec, true);
     
    138139
    139140    // FIXME: Only create when needed <http://webkit.org/b/57163>
    140     RefPtr<MediaControlSeekBackButtonElement> seekBackButton = MediaControlSeekBackButtonElement::create(mediaElement);
     141    RefPtr<MediaControlSeekBackButtonElement> seekBackButton = MediaControlSeekBackButtonElement::create(document);
    141142    controls->m_seekBackButton = seekBackButton.get();
    142143    panel->appendChild(seekBackButton.release(), ec, true);
     
    145146
    146147    // FIXME: Only create when needed <http://webkit.org/b/57163>
    147     RefPtr<MediaControlSeekForwardButtonElement> seekForwardButton = MediaControlSeekForwardButtonElement::create(mediaElement);
     148    RefPtr<MediaControlSeekForwardButtonElement> seekForwardButton = MediaControlSeekForwardButtonElement::create(document);
    148149    controls->m_seekForwardButton = seekForwardButton.get();
    149150    panel->appendChild(seekForwardButton.release(), ec, true);
     
    151152        return 0;
    152153
    153     if (mediaElement->document()->page()->theme()->supportsClosedCaptioning()) {
    154         RefPtr<MediaControlToggleClosedCaptionsButtonElement> toggleClosedCaptionsButton = MediaControlToggleClosedCaptionsButtonElement::create(mediaElement);
     154    if (document->page()->theme()->supportsClosedCaptioning()) {
     155        RefPtr<MediaControlToggleClosedCaptionsButtonElement> toggleClosedCaptionsButton = MediaControlToggleClosedCaptionsButtonElement::create(document);
    155156        controls->m_toggleClosedCaptionsButton = toggleClosedCaptionsButton.get();
    156157        panel->appendChild(toggleClosedCaptionsButton.release(), ec, true);
     
    160161
    161162    // FIXME: Only create when needed <http://webkit.org/b/57163>
    162     RefPtr<MediaControlFullscreenButtonElement> fullScreenButton = MediaControlFullscreenButtonElement::create(mediaElement, controls.get());
     163    RefPtr<MediaControlFullscreenButtonElement> fullScreenButton = MediaControlFullscreenButtonElement::create(document, controls.get());
    163164    controls->m_fullScreenButton = fullScreenButton.get();
    164165    panel->appendChild(fullScreenButton.release(), ec, true);
    165166
    166     RefPtr<MediaControlPanelMuteButtonElement> panelMuteButton = MediaControlPanelMuteButtonElement::create(mediaElement, controls.get());
     167    RefPtr<MediaControlPanelMuteButtonElement> panelMuteButton = MediaControlPanelMuteButtonElement::create(document, controls.get());
    167168    controls->m_panelMuteButton = panelMuteButton.get();
    168169    panel->appendChild(panelMuteButton.release(), ec, true);
     
    170171        return 0;
    171172
    172     if (mediaElement->document()->page()->theme()->usesMediaControlVolumeSlider()) {
    173         RefPtr<MediaControlVolumeSliderContainerElement> volumeSliderContainer = MediaControlVolumeSliderContainerElement::create(mediaElement);
    174 
    175         RefPtr<MediaControlVolumeSliderElement> slider = MediaControlVolumeSliderElement::create(mediaElement);
     173    if (document->page()->theme()->usesMediaControlVolumeSlider()) {
     174        RefPtr<MediaControlVolumeSliderContainerElement> volumeSliderContainer = MediaControlVolumeSliderContainerElement::create(document);
     175
     176        RefPtr<MediaControlVolumeSliderElement> slider = MediaControlVolumeSliderElement::create(document);
    176177        controls->m_volumeSlider = slider.get();
    177178        volumeSliderContainer->appendChild(slider.release(), ec, true);
     
    179180            return 0;
    180181
    181         RefPtr<MediaControlVolumeSliderMuteButtonElement> volumeSliderMuteButton = MediaControlVolumeSliderMuteButtonElement::create(mediaElement);
     182        RefPtr<MediaControlVolumeSliderMuteButtonElement> volumeSliderMuteButton = MediaControlVolumeSliderMuteButtonElement::create(document);
    182183        controls->m_volumeSliderMuteButton = volumeSliderMuteButton.get();
    183184        volumeSliderContainer->appendChild(volumeSliderMuteButton.release(), ec, true);
     
    192193
    193194    // FIXME: Only create when needed <http://webkit.org/b/57163>
    194     RefPtr<MediaControlFullscreenVolumeMinButtonElement> fullScreenMinVolumeButton = MediaControlFullscreenVolumeMinButtonElement::create(mediaElement);
     195    RefPtr<MediaControlFullscreenVolumeMinButtonElement> fullScreenMinVolumeButton = MediaControlFullscreenVolumeMinButtonElement::create(document);
    195196    controls->m_fullScreenMinVolumeButton = fullScreenMinVolumeButton.get();
    196197    panel->appendChild(fullScreenMinVolumeButton.release(), ec, true);
     
    198199        return 0;
    199200
    200     RefPtr<MediaControlFullscreenVolumeSliderElement> fullScreenVolumeSlider = MediaControlFullscreenVolumeSliderElement::create(mediaElement);
     201    RefPtr<MediaControlFullscreenVolumeSliderElement> fullScreenVolumeSlider = MediaControlFullscreenVolumeSliderElement::create(document);
    201202    controls->m_fullScreenVolumeSlider = fullScreenVolumeSlider.get();
    202203    panel->appendChild(fullScreenVolumeSlider.release(), ec, true);
     
    204205        return 0;
    205206
    206     RefPtr<MediaControlFullscreenVolumeMaxButtonElement> fullScreenMaxVolumeButton = MediaControlFullscreenVolumeMaxButtonElement::create(mediaElement);
     207    RefPtr<MediaControlFullscreenVolumeMaxButtonElement> fullScreenMaxVolumeButton = MediaControlFullscreenVolumeMaxButtonElement::create(document);
    207208    controls->m_fullScreenMaxVolumeButton = fullScreenMaxVolumeButton.get();
    208209    panel->appendChild(fullScreenMaxVolumeButton.release(), ec, true);
     
    218219}
    219220
     221void MediaControlRootElement::setMediaController(MediaControllerInterface* controller)
     222{
     223    if (m_mediaController == controller)
     224        return;
     225    m_mediaController = controller;
     226
     227    if (m_rewindButton)
     228        m_rewindButton->setMediaController(controller);
     229    if (m_playButton)
     230        m_playButton->setMediaController(controller);
     231    if (m_returnToRealTimeButton)
     232        m_returnToRealTimeButton->setMediaController(controller);
     233    if (m_statusDisplay)
     234        m_statusDisplay->setMediaController(controller);
     235    if (m_currentTimeDisplay)
     236        m_currentTimeDisplay->setMediaController(controller);
     237    if (m_timeline)
     238        m_timeline->setMediaController(controller);
     239    if (m_timeRemainingDisplay)
     240        m_timeRemainingDisplay->setMediaController(controller);
     241    if (m_timelineContainer)
     242        m_timelineContainer->setMediaController(controller);
     243    if (m_seekBackButton)
     244        m_seekBackButton->setMediaController(controller);
     245    if (m_seekForwardButton)
     246        m_seekForwardButton->setMediaController(controller);
     247    if (m_toggleClosedCaptionsButton)
     248        m_toggleClosedCaptionsButton->setMediaController(controller);
     249    if (m_panelMuteButton)
     250        m_panelMuteButton->setMediaController(controller);
     251    if (m_volumeSlider)
     252        m_volumeSlider->setMediaController(controller);
     253    if (m_volumeSliderMuteButton)
     254        m_volumeSliderMuteButton->setMediaController(controller);
     255    if (m_volumeSliderContainer)
     256        m_volumeSliderContainer->setMediaController(controller);
     257    if (m_fullScreenButton)
     258        m_fullScreenButton->setMediaController(controller);
     259    if (m_fullScreenMinVolumeButton)
     260        m_fullScreenMinVolumeButton->setMediaController(controller);
     261    if (m_fullScreenVolumeSlider)
     262        m_fullScreenVolumeSlider->setMediaController(controller);
     263    if (m_fullScreenMaxVolumeButton)
     264        m_fullScreenMaxVolumeButton->setMediaController(controller);
     265    if (m_panel)
     266        m_panel->setMediaController(controller);
     267    reset();
     268}
     269
    220270void MediaControlRootElement::show()
    221271{
     
    246296    updateStatusDisplay();
    247297
    248     if (m_mediaElement->supportsFullscreen())
     298    if (m_mediaController->supportsFullscreen())
    249299        m_fullScreenButton->show();
    250300    else
    251301        m_fullScreenButton->hide();
    252302
    253     float duration = m_mediaElement->duration();
     303    float duration = m_mediaController->duration();
    254304    if (isfinite(duration) || page->theme()->hasOwnDisabledStateHandlingFor(MediaSliderPart)) {
    255305        m_timeline->setDuration(duration);
    256306        m_timelineContainer->show();
    257         m_timeline->setPosition(m_mediaElement->currentTime());
     307        m_timeline->setPosition(m_mediaController->currentTime());
    258308        updateTimeDisplay();
    259309    } else
    260310        m_timelineContainer->hide();
    261311
    262     if (m_mediaElement->hasAudio() || page->theme()->hasOwnDisabledStateHandlingFor(MediaMuteButtonPart))
     312    if (m_mediaController->hasAudio() || page->theme()->hasOwnDisabledStateHandlingFor(MediaMuteButtonPart))
    263313        m_panelMuteButton->show();
    264314    else
     
    266316
    267317    if (m_volumeSlider)
    268         m_volumeSlider->setVolume(m_mediaElement->volume());
     318        m_volumeSlider->setVolume(m_mediaController->volume());
    269319
    270320    if (m_toggleClosedCaptionsButton) {
    271         if (m_mediaElement->hasClosedCaptions())
     321        if (m_mediaController->hasClosedCaptions())
    272322            m_toggleClosedCaptionsButton->show();
    273323        else
     
    278328
    279329#if ENABLE(FULLSCREEN_API)
    280     if (document()->webkitIsFullScreen() && document()->webkitCurrentFullScreenElement() == m_mediaElement) {
    281         if (m_mediaElement->movieLoadType() == MediaPlayer::LiveStream) {
     330    if (document()->webkitIsFullScreen() && document()->webkitCurrentFullScreenElement() == toParentMediaElement(this)) {
     331        if (m_mediaController->isLiveStream()) {
    282332            m_seekBackButton->hide();
    283333            m_seekForwardButton->hide();
     
    292342    } else
    293343#endif
    294     if (m_mediaElement->movieLoadType() != MediaPlayer::LiveStream) {
     344    if (!m_mediaController->isLiveStream()) {
    295345        m_returnToRealTimeButton->hide();
    296346        m_rewindButton->show();
     
    306356{
    307357    m_playButton->updateDisplayType();
    308     m_timeline->setPosition(m_mediaElement->currentTime());
     358    m_timeline->setPosition(m_mediaController->currentTime());
    309359    updateTimeDisplay();
    310360
    311     if (m_mediaElement->isFullscreen())
     361    if (m_mediaController->isFullscreen())
    312362        startHideFullscreenControlsTimer();
    313363}
     
    315365void MediaControlRootElement::playbackProgressed()
    316366{
    317     m_timeline->setPosition(m_mediaElement->currentTime());
     367    m_timeline->setPosition(m_mediaController->currentTime());
    318368    updateTimeDisplay();
    319369   
    320     if (!m_isMouseOverControls && m_mediaElement->hasVideo())
     370    if (!m_isMouseOverControls && m_mediaController->hasVideo())
    321371        makeTransparent();
    322372}
     
    325375{
    326376    m_playButton->updateDisplayType();
    327     m_timeline->setPosition(m_mediaElement->currentTime());
     377    m_timeline->setPosition(m_mediaController->currentTime());
    328378    updateTimeDisplay();
    329379    makeOpaque();
     
    334384void MediaControlRootElement::updateTimeDisplay()
    335385{
    336     float now = m_mediaElement->currentTime();
    337     float duration = m_mediaElement->duration();
     386    float now = m_mediaController->currentTime();
     387    float duration = m_mediaController->duration();
    338388
    339389    Page* page = document()->page();
     
    377427void MediaControlRootElement::loadedMetadata()
    378428{
    379     if (m_statusDisplay && m_mediaElement->movieLoadType() != MediaPlayer::LiveStream)
     429    if (m_statusDisplay && m_mediaController->isLiveStream())
    380430        m_statusDisplay->hide();
    381431
     
    399449{
    400450    if (m_volumeSlider)
    401         m_volumeSlider->setVolume(m_mediaElement->volume());
     451        m_volumeSlider->setVolume(m_mediaController->volume());
    402452}
    403453
    404454void MediaControlRootElement::enteredFullscreen()
    405455{
    406     if (m_mediaElement->movieLoadType() == MediaPlayer::LiveStream) {
     456    if (m_mediaController->isLiveStream()) {
    407457        m_seekBackButton->hide();
    408458        m_seekForwardButton->hide();
     
    418468    m_panel->setCanBeDragged(true);
    419469
    420     if (Page* page = m_mediaElement->document()->page())
     470    if (Page* page = document()->page())
    421471        page->chrome()->setCursorHiddenUntilMouseMoves(true);
    422472
     
    446496void MediaControlRootElement::showVolumeSlider()
    447497{
    448     if (!m_mediaElement->hasAudio())
     498    if (!m_mediaController->hasAudio())
    449499        return;
    450500
     
    475525        if (!containsRelatedTarget(event)) {
    476526            m_isMouseOverControls = true;
    477             if (!m_mediaElement->canPlay()) {
     527            if (!m_mediaController->canPlay()) {
    478528                makeOpaque();
    479529                if (shouldHideControls())
     
    487537        }
    488538    } else if (event->type() == eventNames().mousemoveEvent) {
    489         if (m_mediaElement->isFullscreen()) {
     539        if (m_mediaController->isFullscreen()) {
    490540            // When we get a mouse move in fullscreen mode, show the media controls, and start a timer
    491541            // that will hide the media controls after a 3 seconds without a mouse move.
     
    499549void MediaControlRootElement::startHideFullscreenControlsTimer()
    500550{
    501     if (!m_mediaElement->isFullscreen())
     551    if (!m_mediaController->isFullscreen())
    502552        return;
    503553   
     
    507557void MediaControlRootElement::hideFullscreenControlsTimerFired(Timer<MediaControlRootElement>*)
    508558{
    509     if (!m_mediaElement->isPlaying())
     559    if (m_mediaController->paused())
    510560        return;
    511561   
    512     if (!m_mediaElement->isFullscreen())
     562    if (!m_mediaController->isFullscreen())
    513563        return;
    514564   
     
    516566        return;
    517567
    518     if (Page* page = m_mediaElement->document()->page())
     568    if (Page* page = document()->page())
    519569        page->chrome()->setCursorHiddenUntilMouseMoves(true);
    520570
  • trunk/Source/WebCore/html/shadow/MediaControlRootElement.h

    r97157 r101810  
    6969class MediaControlRootElement : public MediaControls {
    7070public:
    71     static PassRefPtr<MediaControlRootElement> create(HTMLMediaElement*);
     71    static PassRefPtr<MediaControlRootElement> create(Document*);
    7272
    7373    // MediaControls implementation.
     74    void setMediaController(MediaControllerInterface*);
     75
    7476    void show();
    7577    void hide();
     
    100102
    101103private:
    102     MediaControlRootElement(HTMLMediaElement*);
     104    MediaControlRootElement(Document*);
    103105
    104106    virtual void defaultEventHandler(Event*);
     
    111113    bool containsRelatedTarget(Event*);
    112114
    113     HTMLMediaElement* m_mediaElement;
     115    MediaControllerInterface* m_mediaController;
    114116
    115117    MediaControlRewindButtonElement* m_rewindButton;
  • trunk/Source/WebCore/html/shadow/MediaControlRootElementChromium.cpp

    r97157 r101810  
    3939namespace WebCore {
    4040
    41 MediaControlRootElementChromium::MediaControlRootElementChromium(HTMLMediaElement* mediaElement)
    42     : MediaControls(mediaElement)
    43     , m_mediaElement(mediaElement)
     41MediaControlRootElementChromium::MediaControlRootElementChromium(Document* document)
     42    : MediaControls(document)
     43    , m_mediaController(0)
    4444    , m_playButton(0)
    4545    , m_currentTimeDisplay(0)
     
    5555}
    5656
    57 PassRefPtr<MediaControls> MediaControls::create(HTMLMediaElement* mediaElement)
    58 {
    59     return MediaControlRootElementChromium::create(mediaElement);
    60 }
    61 
    62 PassRefPtr<MediaControlRootElementChromium> MediaControlRootElementChromium::create(HTMLMediaElement* mediaElement)
    63 {
    64     if (!mediaElement->document()->page())
    65         return 0;
    66 
    67     RefPtr<MediaControlRootElementChromium> controls = adoptRef(new MediaControlRootElementChromium(mediaElement));
    68 
    69     RefPtr<MediaControlPanelElement> panel = MediaControlPanelElement::create(mediaElement);
     57PassRefPtr<MediaControls> MediaControls::create(Document* document)
     58{
     59    return MediaControlRootElementChromium::create(document);
     60}
     61
     62PassRefPtr<MediaControlRootElementChromium> MediaControlRootElementChromium::create(Document* document)
     63{
     64    if (!document->page())
     65        return 0;
     66
     67    RefPtr<MediaControlRootElementChromium> controls = adoptRef(new MediaControlRootElementChromium(document));
     68
     69    RefPtr<MediaControlPanelElement> panel = MediaControlPanelElement::create(document);
    7070
    7171    ExceptionCode ec;
    7272
    73     RefPtr<MediaControlPlayButtonElement> playButton = MediaControlPlayButtonElement::create(mediaElement);
     73    RefPtr<MediaControlPlayButtonElement> playButton = MediaControlPlayButtonElement::create(document);
    7474    controls->m_playButton = playButton.get();
    7575    panel->appendChild(playButton.release(), ec, true);
     
    7777        return 0;
    7878
    79     RefPtr<MediaControlTimelineContainerElement> timelineContainer = MediaControlTimelineContainerElement::create(mediaElement);
    80 
    81     RefPtr<MediaControlTimelineElement> timeline = MediaControlTimelineElement::create(mediaElement, controls.get());
     79    RefPtr<MediaControlTimelineContainerElement> timelineContainer = MediaControlTimelineContainerElement::create(document);
     80
     81    RefPtr<MediaControlTimelineElement> timeline = MediaControlTimelineElement::create(document, controls.get());
    8282    controls->m_timeline = timeline.get();
    8383    timelineContainer->appendChild(timeline.release(), ec, true);
     
    8585        return 0;
    8686
    87     RefPtr<MediaControlCurrentTimeDisplayElement> currentTimeDisplay = MediaControlCurrentTimeDisplayElement::create(mediaElement);
     87    RefPtr<MediaControlCurrentTimeDisplayElement> currentTimeDisplay = MediaControlCurrentTimeDisplayElement::create(document);
    8888    controls->m_currentTimeDisplay = currentTimeDisplay.get();
    8989    timelineContainer->appendChild(currentTimeDisplay.release(), ec, true);
     
    9696        return 0;
    9797
    98     RefPtr<MediaControlPanelMuteButtonElement> panelMuteButton = MediaControlPanelMuteButtonElement::create(mediaElement, controls.get());
     98    RefPtr<MediaControlPanelMuteButtonElement> panelMuteButton = MediaControlPanelMuteButtonElement::create(document, controls.get());
    9999    controls->m_panelMuteButton = panelMuteButton.get();
    100100    panel->appendChild(panelMuteButton.release(), ec, true);
     
    102102        return 0;
    103103
    104     RefPtr<MediaControlVolumeSliderContainerElement> volumeSliderContainer = MediaControlVolumeSliderContainerElement::create(mediaElement);
    105 
    106     RefPtr<MediaControlVolumeSliderElement> slider = MediaControlVolumeSliderElement::create(mediaElement);
     104    RefPtr<MediaControlVolumeSliderContainerElement> volumeSliderContainer = MediaControlVolumeSliderContainerElement::create(document);
     105
     106    RefPtr<MediaControlVolumeSliderElement> slider = MediaControlVolumeSliderElement::create(document);
    107107    controls->m_volumeSlider = slider.get();
    108108    volumeSliderContainer->appendChild(slider.release(), ec, true);
     
    123123}
    124124
     125void MediaControlRootElementChromium::setMediaController(MediaControllerInterface* controller)
     126{
     127    if (m_mediaController == controller)
     128        return;
     129    m_mediaController = controller;
     130
     131    if (m_playButton)
     132        m_playButton->setMediaController(controller);
     133    if (m_currentTimeDisplay)
     134        m_currentTimeDisplay->setMediaController(controller);
     135    if (m_timeline)
     136        m_timeline->setMediaController(controller);
     137    if (m_timelineContainer)
     138        m_timelineContainer->setMediaController(controller);
     139    if (m_panelMuteButton)
     140        m_panelMuteButton->setMediaController(controller);
     141    if (m_volumeSlider)
     142        m_volumeSlider->setMediaController(controller);
     143    if (m_volumeSliderContainer)
     144        m_volumeSliderContainer->setMediaController(controller);
     145    if (m_panel)
     146        m_panel->setMediaController(controller);
     147    reset();
     148}
     149
    125150void MediaControlRootElementChromium::show()
    126151{
     
    151176    updateStatusDisplay();
    152177
    153     float duration = m_mediaElement->duration();
     178    float duration = m_mediaController->duration();
    154179    m_timeline->setDuration(duration);
    155180    m_timelineContainer->show();
    156     m_timeline->setPosition(m_mediaElement->currentTime());
     181    m_timeline->setPosition(m_mediaController->currentTime());
    157182    updateTimeDisplay();
    158183
     
    160185
    161186    if (m_volumeSlider)
    162         m_volumeSlider->setVolume(m_mediaElement->volume());
     187        m_volumeSlider->setVolume(m_mediaController->volume());
    163188
    164189    makeOpaque();
     
    168193{
    169194    m_playButton->updateDisplayType();
    170     m_timeline->setPosition(m_mediaElement->currentTime());
     195    m_timeline->setPosition(m_mediaController->currentTime());
    171196    updateTimeDisplay();
    172197}
     
    174199void MediaControlRootElementChromium::playbackProgressed()
    175200{
    176     m_timeline->setPosition(m_mediaElement->currentTime());
     201    m_timeline->setPosition(m_mediaController->currentTime());
    177202    updateTimeDisplay();
    178203
    179     if (!m_isMouseOverControls && m_mediaElement->hasVideo())
     204    if (!m_isMouseOverControls && m_mediaController->hasVideo())
    180205        makeTransparent();
    181206}
     
    184209{
    185210    m_playButton->updateDisplayType();
    186     m_timeline->setPosition(m_mediaElement->currentTime());
     211    m_timeline->setPosition(m_mediaController->currentTime());
    187212    updateTimeDisplay();
    188213    makeOpaque();
     
    191216void MediaControlRootElementChromium::updateTimeDisplay()
    192217{
    193     float now = m_mediaElement->currentTime();
    194     float duration = m_mediaElement->duration();
     218    float now = m_mediaController->currentTime();
     219    float duration = m_mediaController->duration();
    195220
    196221    Page* page = document()->page();
     
    246271        if (!containsRelatedTarget(event)) {
    247272            m_isMouseOverControls = true;
    248             if (!m_mediaElement->canPlay())
     273            if (!m_mediaController->canPlay())
    249274                makeOpaque();
    250275        }
     
    266291void MediaControlRootElementChromium::changedVolume()
    267292{
    268     m_volumeSlider->setVolume(m_mediaElement->volume());
     293    m_volumeSlider->setVolume(m_mediaController->volume());
    269294}
    270295
     
    279304void MediaControlRootElementChromium::showVolumeSlider()
    280305{
    281     if (!m_mediaElement->hasAudio())
     306    if (!m_mediaController->hasAudio())
    282307        return;
    283308
  • trunk/Source/WebCore/html/shadow/MediaControlRootElementChromium.h

    r95901 r101810  
    3535namespace WebCore {
    3636
     37class Document;
    3738class HTMLInputElement;
    38 class HTMLMediaElement;
    3939class Event;
    4040class MediaControlPanelMuteButtonElement;
     
    5050class MediaControlVolumeSliderContainerElement;
    5151class MediaControlPanelElement;
     52class MediaControllerInterface;
    5253class MediaPlayer;
    5354
     
    5758class MediaControlRootElementChromium : public MediaControls {
    5859public:
    59     static PassRefPtr<MediaControlRootElementChromium> create(HTMLMediaElement*);
     60    static PassRefPtr<MediaControlRootElementChromium> create(Document*);
    6061
    6162    // MediaControls implementation.
     63    void setMediaController(MediaControllerInterface*);
     64
    6265    void show();
    6366    void hide();
     
    8891
    8992private:
    90     MediaControlRootElementChromium(HTMLMediaElement*);
     93    MediaControlRootElementChromium(Document*);
    9194
    9295    virtual void defaultEventHandler(Event*);
     
    9699    bool containsRelatedTarget(Event*);
    97100
    98     HTMLMediaElement* m_mediaElement;
     101    MediaControllerInterface* m_mediaController;
    99102
    100103    MediaControlPlayButtonElement* m_playButton;
  • trunk/Source/WebCore/html/shadow/MediaControls.cpp

    r95901 r101810  
    3737namespace WebCore {
    3838
    39 MediaControls::MediaControls(HTMLMediaElement* mediaElement)
    40     : HTMLDivElement(HTMLNames::divTag, mediaElement->document())
     39MediaControls::MediaControls(Document* document)
     40    : HTMLDivElement(HTMLNames::divTag, document)
    4141{
    4242}
  • trunk/Source/WebCore/html/shadow/MediaControls.h

    r95901 r101810  
    3434namespace WebCore {
    3535
    36 class HTMLMediaElement;
     36class MediaControllerInterface;
    3737
    3838class MediaControls : public HTMLDivElement {
     
    4242    // This function is to be implemented in your port-specific media
    4343    // controls implementation.
    44     static PassRefPtr<MediaControls> create(HTMLMediaElement*);
     44    static PassRefPtr<MediaControls> create(Document*);
     45
     46    virtual void setMediaController(MediaControllerInterface*) = 0;
    4547
    4648    virtual void show() = 0;
     
    7274
    7375protected:
    74     MediaControls(HTMLMediaElement*);
     76    MediaControls(Document*);
    7577
    7678private:
Note: See TracChangeset for help on using the changeset viewer.