~ubuntu-branches/ubuntu/lucid/webkit/lucid-updates

#include "Document.h"

#include "Frame.h"

#include "FrameView.h"

#include "GOwnPtrGtk.h"

#include "SecurityOrigin.h"

#include <webkit/webkitwebview.h>

    bool issueError = true;

    bool attemptNextLocation = false;

 

    if (message->structure) {

        const gchar* messageTypeName = gst_structure_get_name(message->structure);

 

        // Redirect messages are sent from elements, like qtdemux, to

        // notify of the new location(s) of the media.

        if (!g_strcmp0(messageTypeName, "redirect")) {

            mp->mediaLocationChanged(message);

            return true;

        }

    }

        if (mp && mp->pipelineReset())

            break;

        else if (err->domain == GST_STREAM_ERROR) {

            attemptNextLocation = true;

        } else if (err->domain == GST_RESOURCE_ERROR)

        if (mp) {

            if (attemptNextLocation)

                issueError = !mp->loadNextLocation();

            if (issueError)

                mp->loadingFailed(error);

        }

void mediaPlayerPrivateSourceChangedCallback(GObject *object, GParamSpec *pspec, gpointer data)

{

    MediaPlayerPrivate* mp = reinterpret_cast<MediaPlayerPrivate*>(data);

    GOwnPtr<GstElement> element;

 

    g_object_get(mp->m_playBin, "source", &element.outPtr(), NULL);

    gst_object_replace((GstObject**) &mp->m_source, (GstObject*) element.get());

 

    if (!element)

        return;

 

    GOwnPtr<char> location;

    g_object_get(element.get(), "location", &location.outPtr(), NULL);

 

    // Do injection only for elements dealing with uris.

    if (!gst_uri_is_valid(location.get()))

        return;

 

    GOwnPtr<SoupURI> uri(soup_uri_new(location.get()));

 

    // Do injection only for http(s) uris.

    if (!SOUP_URI_VALID_FOR_HTTP(uri))

        return;

 

    // Let Apple web servers know we want to access their nice movie trailers.

    if (g_str_equal(uri->host, "movies.apple.com"))

        g_object_set(element.get(), "user-agent", "Quicktime/7.2.0", NULL);

 

    // Set the HTTP referer.

    Frame* frame = mp->m_player->frameView() ? mp->m_player->frameView()->frame() : 0;

    Document* document = frame ? frame->document() : 0;

    if (document) {

        GstStructure* extraHeaders = gst_structure_new("extra-headers",

                                                       "Referer", G_TYPE_STRING,

                                                       document->documentURI().utf8().data(), 0);

        g_object_set(element.get(), "extra-headers", extraHeaders, NULL);

        gst_structure_free(extraHeaders);

    }

 

    // Deal with the cookies from now on.

    GParamSpec* cookiesParamSpec = g_object_class_find_property(G_OBJECT_GET_CLASS(element.get()), "cookies");

 

    // First check if the source element has a cookies property

    // of the format we expect

    if (!cookiesParamSpec || cookiesParamSpec->value_type != G_TYPE_STRV)

        return;

 

    // Then get the cookies for the URI and set them

    SoupSession* session = webkit_get_default_session();

    SoupSessionFeature* cookieJarFeature = soup_session_get_feature(session, SOUP_TYPE_COOKIE_JAR);

    if (!cookieJarFeature)

        return;

 

    SoupCookieJar* cookieJar = SOUP_COOKIE_JAR(cookieJarFeature);

    GOwnPtr<char> cookies(soup_cookie_jar_get_cookies(cookieJar, uri.get(), FALSE));

    char* cookiesStrv[] = {cookies.get(), 0};

    g_object_set(element.get(), "cookies", cookiesStrv, NULL);

}

 

    // This is called when playbin receives the notify::volume signal.

    MediaPlayerPrivate* mp = reinterpret_cast<MediaPlayerPrivate*>(data);

    mp->volumeChanged();

}

 

gboolean notifyVolumeIdleCallback(gpointer data)

{

    MediaPlayerPrivate* mp = reinterpret_cast<MediaPlayerPrivate*>(data);

    mp->volumeChangedCallback();

    return FALSE;

}

 

void mediaPlayerPrivateMuteChangedCallback(GObject *element, GParamSpec *pspec, gpointer data)

{

    // This is called when playbin receives the notify::mute signal.

    MediaPlayerPrivate* mp = reinterpret_cast<MediaPlayerPrivate*>(data);

    mp->muteChanged();

}

 

gboolean notifyMuteIdleCallback(gpointer data)

{

    MediaPlayerPrivate* mp = reinterpret_cast<MediaPlayerPrivate*>(data);

    mp->muteChangedCallback();

    , m_mediaLocations(0)

    , m_mediaLocationCurrentIndex(0)

    , m_resetPipeline(false)

    , m_volumeIdleId(0)

    , m_mediaDuration(0.0)

    , m_muteIdleId(0)

        m_volumeIdleId = 0;

    }

 

    if (m_muteIdleId) {

        g_source_remove(m_muteIdleId);

        m_muteIdleId = 0;

    if (m_mediaLocations) {

        gst_structure_free(m_mediaLocations);

        m_mediaLocations = 0;

    }

 

    if (m_source) {

        gst_object_unref(m_source);

        m_source = 0;

    }

 

    if (m_mediaDuration)

        return m_mediaDuration;

 

void MediaPlayerPrivate::volumeChangedCallback()

{

    double volume;

    g_object_get(m_playBin, "volume", &volume, NULL);

    m_player->volumeChanged(static_cast<float>(volume));

}

 

    if (m_volumeIdleId)

    m_volumeIdleId = g_idle_add((GSourceFunc) notifyVolumeIdleCallback, this);

        m_resetPipeline = state <= GST_STATE_READY;

 

            if (!m_mediaDuration) {

                float newDuration = duration();

                if (!isinf(newDuration))

                    m_mediaDuration = newDuration;

            }

void MediaPlayerPrivate::mediaLocationChanged(GstMessage* message)

{

    if (m_mediaLocations)

        gst_structure_free(m_mediaLocations);

 

    if (message->structure) {

        // This structure can contain:

        // - both a new-location string and embedded locations structure

        // - or only a new-location string.

        m_mediaLocations = gst_structure_copy(message->structure);

        const GValue* locations = gst_structure_get_value(m_mediaLocations, "locations");

 

        if (locations)

            m_mediaLocationCurrentIndex = gst_value_list_get_size(locations) -1;

 

        loadNextLocation();

    }

}

 

bool MediaPlayerPrivate::loadNextLocation()

{

    if (!m_mediaLocations)

        return false;

 

    const GValue* locations = gst_structure_get_value(m_mediaLocations, "locations");

    const gchar* newLocation = 0;

 

    if (!locations) {

        // Fallback on new-location string.

        newLocation = gst_structure_get_string(m_mediaLocations, "new-location");

        if (!newLocation)

            return false;

    }

 

    if (!newLocation) {

        if (m_mediaLocationCurrentIndex < 0) {

            m_mediaLocations = 0;

            return false;

        }

 

        const GValue* location = gst_value_list_get_value(locations,

                                                          m_mediaLocationCurrentIndex);

        const GstStructure* structure = gst_value_get_structure(location);

 

        if (!structure) {

            m_mediaLocationCurrentIndex--;

            return false;

        }

 

        newLocation = gst_structure_get_string(structure, "new-location");

    }

 

    if (newLocation) {

        // Found a candidate. new-location is not always an absolute url

        // though. We need to take the base of the current url and

        // append the value of new-location to it.

 

        gchar* currentLocation = 0;

        g_object_get(m_playBin, "uri", &currentLocation, NULL);

 

        KURL currentUrl(KURL(), currentLocation);

        g_free(currentLocation);

 

        KURL newUrl;

 

        if (gst_uri_is_valid(newLocation))

            newUrl = KURL(KURL(), newLocation);

        else

            newUrl = KURL(KURL(), currentUrl.baseAsString() + newLocation);

 

        RefPtr<SecurityOrigin> securityOrigin = SecurityOrigin::create(currentUrl);

        if (securityOrigin->canRequest(newUrl)) {

            LOG_VERBOSE(Media, "New media url: %s", newUrl.string().utf8().data());

 

            // Reset player states.

            m_networkState = MediaPlayer::Loading;

            m_player->networkStateChanged();

            m_readyState = MediaPlayer::HaveNothing;

            m_player->readyStateChanged();

 

            // Reset pipeline state.

            m_resetPipeline = true;

            gst_element_set_state(m_playBin, GST_STATE_READY);

 

            GstState state;

            gst_element_get_state(m_playBin, &state, 0, 0);

            if (state <= GST_STATE_READY) {

                // Set the new uri and start playing.

                g_object_set(m_playBin, "uri", newUrl.string().utf8().data(), NULL);

                gst_element_set_state(m_playBin, GST_STATE_PLAYING);

                return true;

            }

        }

    }

    m_mediaLocationCurrentIndex--;

    return false;

 

}

 

    // EOS was reached but in case of reverse playback the position is

    // not always 0. So to not confuse the HTMLMediaElement we

    // synchronize position and duration values.

    float now = currentTime();

    if (now > 0)

        m_mediaDuration = now;

    gst_element_set_state(m_playBin, GST_STATE_PAUSED);

 

    // Reset cached media duration

    m_mediaDuration = 0;

 

    // And re-cache it if possible.

    float newDuration = duration();

    if (!isinf(newDuration))

        m_mediaDuration = newDuration;

 

bool MediaPlayerPrivate::supportsMuting() const

{

    return true;

}

 

void MediaPlayerPrivate::setMuted(bool muted)

{

    if (!m_playBin)

        return;

 

    g_object_set(m_playBin, "mute", muted, NULL);

}

 

void MediaPlayerPrivate::muteChangedCallback()

{

    gboolean muted;

    g_object_get(m_playBin, "mute", &muted, NULL);

    m_player->muteChanged(static_cast<bool>(muted));

}

 

void MediaPlayerPrivate::muteChanged()

{

    if (m_muteIdleId)

        g_source_remove(m_muteIdleId);

 

    m_muteIdleId = g_idle_add((GSourceFunc) notifyMuteIdleCallback, this);

}

 

    g_signal_connect(m_playBin, "notify::source", G_CALLBACK(mediaPlayerPrivateSourceChangedCallback), this);

    g_signal_connect(m_playBin, "notify::mute", G_CALLBACK(mediaPlayerPrivateMuteChangedCallback), this);