/*

 * Copyright (C) 2007, 2008, 2009, 2010 Apple Inc. All rights reserved.

 *

 * Redistribution and use in source and binary forms, with or without

 * modification, are permitted provided that the following conditions

 * are met:

 * 1. Redistributions of source code must retain the above copyright

 *    notice, this list of conditions and the following disclaimer.

 * 2. Redistributions in binary form must reproduce the above copyright

 *    notice, this list of conditions and the following disclaimer in the

 *    documentation and/or other materials provided with the distribution.

 *

 * THIS SOFTWARE IS PROVIDED BY APPLE COMPUTER, INC. ``AS IS'' AND ANY

 * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE

 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR

 * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE COMPUTER, INC. OR

 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,

 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,

 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR

 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY

 * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE

 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 

 */

#include "config.h"

#if ENABLE(VIDEO)

#include "HTMLMediaElement.h"

#include "Attribute.h"

#include "CSSHelper.h"

#include "CSSPropertyNames.h"

#include "CSSValueKeywords.h"

#include "Chrome.h"

#include "ChromeClient.h"

#include "ClientRect.h"

#include "ClientRectList.h"

#include "ContentType.h"

#include "DocLoader.h"

#include "Event.h"

#include "EventNames.h"

#include "ExceptionCode.h"

#include "Frame.h"

#include "FrameLoader.h"

#include "FrameLoaderClient.h"

#include "FrameView.h"

#include "HTMLDocument.h"

#include "HTMLNames.h"

#include "HTMLSourceElement.h"

#include "HTMLVideoElement.h"

#include "MIMETypeRegistry.h"

#include "MediaDocument.h"

#include "MediaError.h"

#include "MediaList.h"

#include "MediaPlayer.h"

#include "MediaQueryEvaluator.h"

#include "Page.h"

#include "RenderVideo.h"

#include "RenderView.h"

#include "ScriptEventListener.h"

#include "Settings.h"

#include "TimeRanges.h"

#include <limits>

#include <wtf/CurrentTime.h>

#include <wtf/MathExtras.h>

#if USE(ACCELERATED_COMPOSITING)

#include "RenderView.h"

#include "RenderLayerCompositor.h"

#endif

#if ENABLE(PLUGIN_PROXY_FOR_VIDEO)

#include "RenderEmbeddedObject.h"

#include "Widget.h"

#endif

using namespace std;

namespace WebCore {

using namespace HTMLNames;

HTMLMediaElement::HTMLMediaElement(const QualifiedName& tagName, Document* doc)

    : HTMLElement(tagName, doc)

    , m_loadTimer(this, &HTMLMediaElement::loadTimerFired)

    , m_asyncEventTimer(this, &HTMLMediaElement::asyncEventTimerFired)

    , m_progressEventTimer(this, &HTMLMediaElement::progressEventTimerFired)

    , m_playbackProgressTimer(this, &HTMLMediaElement::playbackProgressTimerFired)

    , m_playedTimeRanges()

    , m_playbackRate(1.0f)

    , m_defaultPlaybackRate(1.0f)

    , m_webkitPreservesPitch(true)

    , m_networkState(NETWORK_EMPTY)

    , m_readyState(HAVE_NOTHING)

    , m_readyStateMaximum(HAVE_NOTHING)

    , m_volume(1.0f)

    , m_lastSeekTime(0)

    , m_previousProgress(0)

    , m_previousProgressTime(numeric_limits<double>::max())

    , m_lastTimeUpdateEventWallTime(0)

    , m_lastTimeUpdateEventMovieTime(numeric_limits<float>::max())

    , m_loadState(WaitingForSource)

    , m_currentSourceNode(0)

    , m_player(0)

#if ENABLE(PLUGIN_PROXY_FOR_VIDEO)

    , m_proxyWidget(0)

#endif

    , m_restrictions(NoRestrictions)

    , m_preload(MediaPlayer::Auto)

    , m_playing(false)

    , m_processingMediaPlayerCallback(0)

    , m_isWaitingUntilMediaCanStart(false)

    , m_processingLoad(false)

    , m_delayingTheLoadEvent(false)

    , m_haveFiredLoadedData(false)

    , m_inActiveDocument(true)

    , m_autoplaying(true)

    , m_muted(false)

    , m_paused(true)

    , m_seeking(false)

    , m_sentStalledEvent(false)

    , m_sentEndEvent(false)

    , m_pausedInternal(false)

    , m_sendProgressEvents(true)

    , m_isFullscreen(false)

    , m_closedCaptionsVisible(false)

#if ENABLE(PLUGIN_PROXY_FOR_VIDEO)

    , m_needWidgetUpdate(false)

#endif

    , m_dispatchingCanPlayEvent(false)

    , m_loadInitiatedByUserGesture(false)

    , m_completelyLoaded(false)

{

    document()->registerForDocumentActivationCallbacks(this);

    document()->registerForMediaVolumeCallbacks(this);

}

HTMLMediaElement::~HTMLMediaElement()

{

    if (m_isWaitingUntilMediaCanStart)

        document()->removeMediaCanStartListener(this);

    document()->unregisterForDocumentActivationCallbacks(this);

    document()->unregisterForMediaVolumeCallbacks(this);

}

void HTMLMediaElement::willMoveToNewOwnerDocument()

{

    if (m_isWaitingUntilMediaCanStart)

        document()->removeMediaCanStartListener(this);

    document()->unregisterForDocumentActivationCallbacks(this);

    document()->unregisterForMediaVolumeCallbacks(this);

    HTMLElement::willMoveToNewOwnerDocument();

}

void HTMLMediaElement::didMoveToNewOwnerDocument()

{

    if (m_isWaitingUntilMediaCanStart)

        document()->addMediaCanStartListener(this);

    document()->registerForDocumentActivationCallbacks(this);

    document()->registerForMediaVolumeCallbacks(this);

    HTMLElement::didMoveToNewOwnerDocument();

}

bool HTMLMediaElement::checkDTD(const Node* newChild)

{

    return newChild->hasTagName(sourceTag) || HTMLElement::checkDTD(newChild);

}

void HTMLMediaElement::attributeChanged(Attribute* attr, bool preserveDecls)

{

    HTMLElement::attributeChanged(attr, preserveDecls);

    const QualifiedName& attrName = attr->name();

    if (attrName == srcAttr) {

        // Trigger a reload, as long as the 'src' attribute is present.

        if (!getAttribute(srcAttr).isEmpty())

            scheduleLoad();

    }

    else if (attrName == controlsAttr) {

#if !ENABLE(PLUGIN_PROXY_FOR_VIDEO)

        if (!isVideo() && attached() && (controls() != (renderer() != 0))) {

            detach();

            attach();

        }

        if (renderer())

            renderer()->updateFromElement();

#else

        if (m_player)

            m_player->setControls(controls());

#endif

    }

}

void HTMLMediaElement::parseMappedAttribute(Attribute* attr)

{

    const QualifiedName& attrName = attr->name();

    if (attrName == preloadAttr) {

        String value = attr->value();

        if (equalIgnoringCase(value, "none"))

            m_preload = MediaPlayer::None;

        else if (equalIgnoringCase(value, "metadata"))

            m_preload = MediaPlayer::MetaData;

        else {

            // The spec does not define an "invalid value default" but "auto" is suggested as the

            // "missing value default", so use it for everything except "none" and "metadata"

            m_preload = MediaPlayer::Auto;

        }

        // The attribute must be ignored if the autoplay attribute is present

        if (!autoplay() && m_player)

            m_player->setPreload(m_preload);

    } else if (attrName == onabortAttr)

        setAttributeEventListener(eventNames().abortEvent, createAttributeEventListener(this, attr));

    else if (attrName == onbeforeloadAttr)

        setAttributeEventListener(eventNames().beforeloadEvent, createAttributeEventListener(this, attr));

    else if (attrName == oncanplayAttr)

        setAttributeEventListener(eventNames().canplayEvent, createAttributeEventListener(this, attr));

    else if (attrName == oncanplaythroughAttr)

        setAttributeEventListener(eventNames().canplaythroughEvent, createAttributeEventListener(this, attr));

    else if (attrName == ondurationchangeAttr)

        setAttributeEventListener(eventNames().durationchangeEvent, createAttributeEventListener(this, attr));

    else if (attrName == onemptiedAttr)

        setAttributeEventListener(eventNames().emptiedEvent, createAttributeEventListener(this, attr));

    else if (attrName == onendedAttr)

        setAttributeEventListener(eventNames().endedEvent, createAttributeEventListener(this, attr));

    else if (attrName == onerrorAttr)

        setAttributeEventListener(eventNames().errorEvent, createAttributeEventListener(this, attr));

    else if (attrName == onloadeddataAttr)

        setAttributeEventListener(eventNames().loadeddataEvent, createAttributeEventListener(this, attr));

    else if (attrName == onloadedmetadataAttr)

        setAttributeEventListener(eventNames().loadedmetadataEvent, createAttributeEventListener(this, attr));

    else if (attrName == onloadstartAttr)

        setAttributeEventListener(eventNames().loadstartEvent, createAttributeEventListener(this, attr));

    else if (attrName == onpauseAttr)

        setAttributeEventListener(eventNames().pauseEvent, createAttributeEventListener(this, attr));

    else if (attrName == onplayAttr)

        setAttributeEventListener(eventNames().playEvent, createAttributeEventListener(this, attr));

    else if (attrName == onplayingAttr)

        setAttributeEventListener(eventNames().playingEvent, createAttributeEventListener(this, attr));

    else if (attrName == onprogressAttr)

        setAttributeEventListener(eventNames().progressEvent, createAttributeEventListener(this, attr));

    else if (attrName == onratechangeAttr)

        setAttributeEventListener(eventNames().ratechangeEvent, createAttributeEventListener(this, attr));

    else if (attrName == onseekedAttr)

        setAttributeEventListener(eventNames().seekedEvent, createAttributeEventListener(this, attr));

    else if (attrName == onseekingAttr)

        setAttributeEventListener(eventNames().seekingEvent, createAttributeEventListener(this, attr));

    else if (attrName == onstalledAttr)

        setAttributeEventListener(eventNames().stalledEvent, createAttributeEventListener(this, attr));

    else if (attrName == onsuspendAttr)

        setAttributeEventListener(eventNames().suspendEvent, createAttributeEventListener(this, attr));

    else if (attrName == ontimeupdateAttr)

        setAttributeEventListener(eventNames().timeupdateEvent, createAttributeEventListener(this, attr));

    else if (attrName == onvolumechangeAttr)

        setAttributeEventListener(eventNames().volumechangeEvent, createAttributeEventListener(this, attr));

    else if (attrName == onwaitingAttr)

        setAttributeEventListener(eventNames().waitingEvent, createAttributeEventListener(this, attr));

    else if (attrName == onwebkitbeginfullscreenAttr)

        setAttributeEventListener(eventNames().webkitbeginfullscreenEvent, createAttributeEventListener(this, attr));

    else if (attrName == onwebkitendfullscreenAttr)

        setAttributeEventListener(eventNames().webkitendfullscreenEvent, createAttributeEventListener(this, attr));

    else

        HTMLElement::parseMappedAttribute(attr);

}

bool HTMLMediaElement::rendererIsNeeded(RenderStyle* style)

{

#if ENABLE(PLUGIN_PROXY_FOR_VIDEO)

    UNUSED_PARAM(style);

    Frame* frame = document()->frame();

    if (!frame)

        return false;

    return true;

#else

    return controls() ? HTMLElement::rendererIsNeeded(style) : false;

#endif

}

RenderObject* HTMLMediaElement::createRenderer(RenderArena* arena, RenderStyle*)

{

#if ENABLE(PLUGIN_PROXY_FOR_VIDEO)

    // Setup the renderer if we already have a proxy widget.

    RenderEmbeddedObject* mediaRenderer = new (arena) RenderEmbeddedObject(this);

    if (m_proxyWidget) {

        mediaRenderer->setWidget(m_proxyWidget);

        Frame* frame = document()->frame();

        FrameLoader* loader = frame ? frame->loader() : 0;

        if (loader)

            loader->showMediaPlayerProxyPlugin(m_proxyWidget.get());

    }

    return mediaRenderer;

#else

    return new (arena) RenderMedia(this);

#endif

}

void HTMLMediaElement::insertedIntoDocument()

{

    HTMLElement::insertedIntoDocument();

    if (!src().isEmpty() && m_networkState == NETWORK_EMPTY)

        scheduleLoad();

}

void HTMLMediaElement::removedFromDocument()

{

    if (m_networkState > NETWORK_EMPTY)

        pause(processingUserGesture());

    if (m_isFullscreen)

        exitFullscreen();

    HTMLElement::removedFromDocument();

}

void HTMLMediaElement::attach()

{

    ASSERT(!attached());

#if ENABLE(PLUGIN_PROXY_FOR_VIDEO)

    m_needWidgetUpdate = true;

#endif

    HTMLElement::attach();

    if (renderer())

        renderer()->updateFromElement();

#if ENABLE(PLUGIN_PROXY_FOR_VIDEO)

    else if (m_proxyWidget) {

        Frame* frame = document()->frame();

        FrameLoader* loader = frame ? frame->loader() : 0;

        if (loader)

            loader->hideMediaPlayerProxyPlugin(m_proxyWidget.get());

    }

#endif

}

void HTMLMediaElement::recalcStyle(StyleChange change)

{

    HTMLElement::recalcStyle(change);

    if (renderer())

        renderer()->updateFromElement();

}

void HTMLMediaElement::scheduleLoad()

{

#if ENABLE(PLUGIN_PROXY_FOR_VIDEO)

    createMediaPlayerProxy();

#endif

    if (m_loadTimer.isActive())

        return;

    prepareForLoad();

    m_loadTimer.startOneShot(0);

}

void HTMLMediaElement::scheduleNextSourceChild()

{

    // Schedule the timer to try the next <source> element WITHOUT resetting state ala prepareForLoad.

    m_loadTimer.startOneShot(0);

}

void HTMLMediaElement::scheduleEvent(const AtomicString& eventName)

{

    m_pendingEvents.append(Event::create(eventName, false, true));

    if (!m_asyncEventTimer.isActive())

        m_asyncEventTimer.startOneShot(0);

}

void HTMLMediaElement::asyncEventTimerFired(Timer<HTMLMediaElement>*)

{

    Vector<RefPtr<Event> > pendingEvents;

    ExceptionCode ec = 0;

    m_pendingEvents.swap(pendingEvents);

    unsigned count = pendingEvents.size();

    for (unsigned ndx = 0; ndx < count; ++ndx) {

        if (pendingEvents[ndx]->type() == eventNames().canplayEvent) {

            m_dispatchingCanPlayEvent = true;

            dispatchEvent(pendingEvents[ndx].release(), ec);

            m_dispatchingCanPlayEvent = false;

        } else

            dispatchEvent(pendingEvents[ndx].release(), ec);

    }

}

void HTMLMediaElement::loadTimerFired(Timer<HTMLMediaElement>*)

{

    if (m_loadState == LoadingFromSourceElement)

        loadNextSourceChild();

    else

        loadInternal();

}

static String serializeTimeOffset(float time)

{

    String timeString = String::number(time);

    // FIXME serialize time offset values properly (format not specified yet)

    timeString.append("s");

    return timeString;

}

static float parseTimeOffset(const String& timeString, bool* ok = 0)

{

    const UChar* characters = timeString.characters();

    unsigned length = timeString.length();

    if (length && characters[length - 1] == 's')

        length--;

    // FIXME parse time offset values (format not specified yet)

    float val = charactersToFloat(characters, length, ok);

    return val;

}

float HTMLMediaElement::getTimeOffsetAttribute(const QualifiedName& name, float valueOnError) const

{

    bool ok;

    String timeString = getAttribute(name);

    float result = parseTimeOffset(timeString, &ok);

    if (ok)

        return result;

    return valueOnError;

}

void HTMLMediaElement::setTimeOffsetAttribute(const QualifiedName& name, float value)

{

    setAttribute(name, serializeTimeOffset(value));

}

PassRefPtr<MediaError> HTMLMediaElement::error() const 

{

    return m_error;

}

KURL HTMLMediaElement::src() const

{

    return getNonEmptyURLAttribute(srcAttr);

}

void HTMLMediaElement::setSrc(const String& url)

{

    setAttribute(srcAttr, url);

}

String HTMLMediaElement::currentSrc() const

{

    return m_currentSrc;

}

HTMLMediaElement::NetworkState HTMLMediaElement::networkState() const

{

    return m_networkState;

}

String HTMLMediaElement::canPlayType(const String& mimeType) const

{

    MediaPlayer::SupportsType support = MediaPlayer::supportsType(ContentType(mimeType));

    String canPlay;

    // 4.8.10.3

    switch (support)

    {

        case MediaPlayer::IsNotSupported:

            canPlay = "";

            break;

        case MediaPlayer::MayBeSupported:

            canPlay = "maybe";

            break;

        case MediaPlayer::IsSupported:

            canPlay = "probably";

            break;

    }

    return canPlay;

}

void HTMLMediaElement::load(bool isUserGesture, ExceptionCode& ec)

{

    if (m_restrictions & RequireUserGestureForLoadRestriction && !isUserGesture)

        ec = INVALID_STATE_ERR;

    else {

        m_loadInitiatedByUserGesture = isUserGesture;

        prepareForLoad();

        loadInternal();

    }

}

void HTMLMediaElement::prepareForLoad()

{

    // Perform the cleanup required for the resource load algorithm to run.

    stopPeriodicTimers();

    m_loadTimer.stop();

    m_sentStalledEvent = false;

    m_haveFiredLoadedData = false;

    m_completelyLoaded = false;

    // 1 - Abort any already-running instance of the resource selection algorithm for this element.

    m_currentSourceNode = 0;

    // 2 - If there are any tasks from the media element's media element event task source in 

    // one of the task queues, then remove those tasks.

    cancelPendingEventsAndCallbacks();

    // 3 - If the media element's networkState is set to NETWORK_LOADING or NETWORK_IDLE, queue

    // a task to fire a simple event named abort at the media element.

    if (m_networkState == NETWORK_LOADING || m_networkState == NETWORK_IDLE)

        scheduleEvent(eventNames().abortEvent);

#if !ENABLE(PLUGIN_PROXY_FOR_VIDEO)

    m_player = MediaPlayer::create(this);

#else

    createMediaPlayerProxy();

#endif

    // 4 - If the media element's networkState is not set to NETWORK_EMPTY, then run these substeps

    if (m_networkState != NETWORK_EMPTY) {

        m_networkState = NETWORK_EMPTY;

        m_readyState = HAVE_NOTHING;

        m_readyStateMaximum = HAVE_NOTHING;

        m_paused = true;

        m_seeking = false;

        scheduleEvent(eventNames().emptiedEvent);