Merge remote branch 'origin/4.6' into qt-4.7-from-4.6

Conflicts:
	src/3rdparty/webkit/VERSION
	src/3rdparty/webkit/WebCore/ChangeLog
	src/3rdparty/webkit/WebCore/page/FrameView.cpp
	src/3rdparty/webkit/WebCore/rendering/RenderWidget.cpp
	src/3rdparty/webkit/WebKit/qt/symbian/eabi/QtWebKitu.def
	src/s60installs/bwins/QtCoreu.def
	src/s60installs/bwins/QtGuiu.def
	src/s60installs/bwins/QtNetworku.def
	src/s60installs/eabi/QtGuiu.def
	tests/auto/qscriptextqobject/tst_qscriptextqobject.cpp

10 files changed, 169 insertions, 97 deletions

diff --git a/src/3rdparty/phonon/mmf/abstractmediaplayer.cpp b/src/3rdparty/phonon/mmf/abstractmediaplayer.cpp
index 6356c21..be2a568 100644
--- a/src/3rdparty/phonon/mmf/abstractmediaplayer.cpp
+++ b/src/3rdparty/phonon/mmf/abstractmediaplayer.cpp
@@ -48,7 +48,7 @@ MMF::AbstractMediaPlayer::AbstractMediaPlayer
     (MediaObject *parent, const AbstractPlayer *player)
         :   AbstractPlayer(player)
         ,   m_parent(parent)
-        ,   m_playPending(false)
+        ,   m_pending(NothingPending)
         ,   m_positionTimer(new QTimer(this))
         ,   m_bufferStatusTimer(new QTimer(this))
         ,   m_mmfMaxVolume(NullMaxVolume)
@@ -74,14 +74,12 @@ void MMF::AbstractMediaPlayer::play()
         break;
 
     case LoadingState:
-        m_playPending = true;
+        setPending(PlayPending);
         break;
 
     case StoppedState:
     case PausedState:
-        doPlay();
-        startPositionTimer();
-        changeState(PlayingState);
+        startPlayback();
         break;
 
     case PlayingState:
@@ -103,14 +101,16 @@ void MMF::AbstractMediaPlayer::pause()
     TRACE_CONTEXT(AbstractMediaPlayer::pause, EAudioApi);
     TRACE_ENTRY("state %d", privateState());
 
-    m_playPending = false;
     stopTimers();
 
     switch (privateState()) {
     case GroundState:
     case LoadingState:
-    case PausedState:
     case StoppedState:
+        setPending(PausePending);
+        break;
+
+    case PausedState:
         // Do nothing
         break;
 
@@ -135,7 +135,7 @@ void MMF::AbstractMediaPlayer::stop()
     TRACE_CONTEXT(AbstractMediaPlayer::stop, EAudioApi);
     TRACE_ENTRY("state %d", privateState());
 
-    m_playPending = false;
+    setPending(NothingPending);
     stopTimers();
 
     switch (privateState()) {
@@ -365,6 +365,18 @@ void MMF::AbstractMediaPlayer::maxVolumeChanged(int mmfMaxVolume)
     doVolumeChanged();
 }
 
+void MMF::AbstractMediaPlayer::loadingComplete(int error)
+{
+    Q_ASSERT(Phonon::LoadingState == state());
+
+    if (KErrNone == error) {
+        updateMetaData();
+        changeState(StoppedState);
+    } else {
+        setError(tr("Loading clip failed"), error);
+    }
+}
+
 void MMF::AbstractMediaPlayer::playbackComplete(int error)
 {
     stopTimers();
@@ -377,7 +389,7 @@ void MMF::AbstractMediaPlayer::playbackComplete(int error)
     }
 
     if (KErrNone == error) {
-        changeState(StoppedState);
+        changeState(PausedState);
 
         // MediaObject::switchToNextSource deletes the current player, so we
         // call it via delayed slot invokation to ensure that this object does
@@ -386,6 +398,7 @@ void MMF::AbstractMediaPlayer::playbackComplete(int error)
     }
     else {
         setError(tr("Playback complete"), error);
+        emit finished();
     }
 }
 
@@ -440,11 +453,39 @@ void MMF::AbstractMediaPlayer::resetMarksIfRewound()
             m_aboutToFinishSent = false;
 }
 
+void MMF::AbstractMediaPlayer::setPending(Pending pending)
+{
+    const Phonon::State oldState = state();
+    m_pending = pending;
+    const Phonon::State newState = state();
+    if (newState != oldState)
+        emit stateChanged(newState, oldState);
+}
+
+void MMF::AbstractMediaPlayer::startPlayback()
+{
+    doPlay();
+    startPositionTimer();
+    changeState(PlayingState);
+}
+
 void MMF::AbstractMediaPlayer::bufferStatusTick()
 {
     emit MMF::AbstractPlayer::bufferStatus(bufferStatus());
 }
 
+Phonon::State MMF::AbstractMediaPlayer::phononState(PrivateState state) const
+{
+    Phonon::State result = AbstractPlayer::phononState(state);
+
+    if (PausePending == m_pending) {
+        Q_ASSERT(Phonon::StoppedState == result || Phonon::LoadingState == result);
+        result = Phonon::PausedState;
+    }
+
+    return result;
+}
+
 void MMF::AbstractMediaPlayer::changeState(PrivateState newState)
 {
     TRACE_CONTEXT(AbstractMediaPlayer::changeState, EAudioInternal);
@@ -452,20 +493,26 @@ void MMF::AbstractMediaPlayer::changeState(PrivateState newState)
     const Phonon::State oldPhononState = phononState(privateState());
     const Phonon::State newPhononState = phononState(newState);
 
-    // TODO: add some invariants to check that the transition is valid
-    AbstractPlayer::changeState(newState);
-
     if (LoadingState == oldPhononState && StoppedState == newPhononState) {
-        // Ensure initial volume is set on MMF API before starting playback
-        doVolumeChanged();
-
-        // Check whether play() was called while clip was being loaded.  If so,
-        // playback should be started now
-        if (m_playPending) {
-            TRACE_0("play was called while loading; starting playback now");
-            m_playPending = false;
-            play();
+        switch (m_pending) {
+        case NothingPending:
+            AbstractPlayer::changeState(newState);
+            break;
+
+        case PlayPending:
+            changeState(PlayingState); // necessary in order to apply initial volume
+            doVolumeChanged();
+            startPlayback();
+            break;
+
+        case PausePending:
+            AbstractPlayer::changeState(PausedState);
+            break;
         }
+
+        setPending(NothingPending);
+    } else {
+        AbstractPlayer::changeState(newState);
     }
 }
 
diff --git a/src/3rdparty/phonon/mmf/abstractmediaplayer.h b/src/3rdparty/phonon/mmf/abstractmediaplayer.h
index 308b5af..23a8233 100644
--- a/src/3rdparty/phonon/mmf/abstractmediaplayer.h
+++ b/src/3rdparty/phonon/mmf/abstractmediaplayer.h
@@ -60,6 +60,8 @@ public:
 protected:
     // AbstractPlayer
     virtual void doSetTickInterval(qint32 interval);
+    virtual Phonon::State phononState(PrivateState state) const;
+    virtual void changeState(PrivateState newState);
 
     virtual void doPlay() = 0;
     virtual void doPause() = 0;
@@ -70,7 +72,6 @@ protected:
     virtual int openUrl(const QString& url) = 0;
     virtual int bufferStatus() const = 0;
     virtual void close() = 0;
-    virtual void changeState(PrivateState newState);
 
     void updateMetaData();
     virtual int numberOfMetaDataEntries() const = 0;
@@ -80,6 +81,7 @@ protected:
     void bufferingStarted();
     void bufferingComplete();
     void maxVolumeChanged(int maxVolume);
+    void loadingComplete(int error);
     void playbackComplete(int error);
 
     static qint64 toMilliSeconds(const TTimeIntervalMicroSeconds &);
@@ -93,6 +95,15 @@ private:
     void doVolumeChanged();
     void emitMarksIfReached(qint64 position);
     void resetMarksIfRewound();
+    void startPlayback();
+
+    enum Pending {
+        NothingPending,
+        PausePending,
+        PlayPending
+    };
+
+    void setPending(Pending pending);
 
 private Q_SLOTS:
     void positionTick();
@@ -101,12 +112,7 @@ private Q_SLOTS:
 private:
     MediaObject *const          m_parent;
 
-    /**
-     * This flag is set to true if play is called when the object is
-     * in a Loading state.  Once loading is complete, playback will
-     * be started.
-     */
-    bool                        m_playPending;
+    Pending                     m_pending;
 
     QScopedPointer<QTimer>      m_positionTimer;
 
diff --git a/src/3rdparty/phonon/mmf/abstractplayer.cpp b/src/3rdparty/phonon/mmf/abstractplayer.cpp
index 421155b..77d7ae0 100644
--- a/src/3rdparty/phonon/mmf/abstractplayer.cpp
+++ b/src/3rdparty/phonon/mmf/abstractplayer.cpp
@@ -48,6 +48,11 @@ MMF::AbstractPlayer::AbstractPlayer(const AbstractPlayer *player)
         m_tickInterval = player->m_tickInterval;
         m_transitionTime = player->m_transitionTime;
         m_prefinishMark = player->m_prefinishMark;
+
+        // This is to prevent unwanted state transitions occurring as a result
+        // of MediaObject::switchToNextSource() during playlist playback.
+        if (StoppedState == player->m_state)
+            m_state = player->m_state;
     }
 }
 
@@ -141,7 +146,7 @@ Phonon::State MMF::AbstractPlayer::phononState() const
     return phononState(m_state);
 }
 
-Phonon::State MMF::AbstractPlayer::phononState(PrivateState state)
+Phonon::State MMF::AbstractPlayer::phononState(PrivateState state) const
 {
     const Phonon::State phononState =
         GroundState == state
diff --git a/src/3rdparty/phonon/mmf/abstractplayer.h b/src/3rdparty/phonon/mmf/abstractplayer.h
index 92bd87e..ab892f5 100644
--- a/src/3rdparty/phonon/mmf/abstractplayer.h
+++ b/src/3rdparty/phonon/mmf/abstractplayer.h
@@ -133,7 +133,7 @@ protected:
     /**
      * Converts PrivateState into the corresponding Phonon::State
      */
-    static Phonon::State phononState(PrivateState state);
+    virtual Phonon::State phononState(PrivateState state) const;
 
     virtual void videoOutputChanged();
 
diff --git a/src/3rdparty/phonon/mmf/abstractvideoplayer.cpp b/src/3rdparty/phonon/mmf/abstractvideoplayer.cpp
index c2bcce0..2e0ab1c 100644
--- a/src/3rdparty/phonon/mmf/abstractvideoplayer.cpp
+++ b/src/3rdparty/phonon/mmf/abstractvideoplayer.cpp
@@ -268,11 +268,10 @@ void MMF::AbstractVideoPlayer::MvpuoPrepareComplete(TInt aError)
         handlePendingParametersChanged();
 
         emit totalTimeChanged(totalTime());
-        changeState(StoppedState);
-    } else {
-        setError(tr("Buffering clip failed"), err);
     }
 
+    loadingComplete(aError);
+
     TRACE_EXIT_0();
 }
 
diff --git a/src/3rdparty/phonon/mmf/audioplayer.cpp b/src/3rdparty/phonon/mmf/audioplayer.cpp
index ee07229..77a0964 100644
--- a/src/3rdparty/phonon/mmf/audioplayer.cpp
+++ b/src/3rdparty/phonon/mmf/audioplayer.cpp
@@ -203,12 +203,10 @@ void MMF::AudioPlayer::MapcInitComplete(TInt aError,
         maxVolumeChanged(m_player->MaxVolume());
         m_totalTime = toMilliSeconds(m_player->Duration());
         emit totalTimeChanged(m_totalTime);
-        updateMetaData();
-        changeState(StoppedState);
-    } else {
-        setError(tr("Opening clip failed"), aError);
     }
 
+    loadingComplete(aError);
+
     TRACE_EXIT_0();
 }
 
diff --git a/src/3rdparty/phonon/mmf/mediaobject.cpp b/src/3rdparty/phonon/mmf/mediaobject.cpp
index ee459e6..e1b921b 100644
--- a/src/3rdparty/phonon/mmf/mediaobject.cpp
+++ b/src/3rdparty/phonon/mmf/mediaobject.cpp
@@ -323,11 +323,12 @@ void MMF::MediaObject::createPlayer(const MediaSource &source)
     connect(m_player.data(), SIGNAL(totalTimeChanged(qint64)), SIGNAL(totalTimeChanged(qint64)));
     connect(m_player.data(), SIGNAL(stateChanged(Phonon::State,Phonon::State)), SIGNAL(stateChanged(Phonon::State,Phonon::State)));
     connect(m_player.data(), SIGNAL(finished()), SIGNAL(finished()));
-    connect(m_player.data(), SIGNAL(tick(qint64)), SIGNAL(tick(qint64)));
     connect(m_player.data(), SIGNAL(bufferStatus(int)), SIGNAL(bufferStatus(int)));
     connect(m_player.data(), SIGNAL(metaDataChanged(QMultiMap<QString,QString>)), SIGNAL(metaDataChanged(QMultiMap<QString,QString>)));
     connect(m_player.data(), SIGNAL(aboutToFinish()), SIGNAL(aboutToFinish()));
-    connect(m_player.data(), SIGNAL(prefinishMarkReached(qint32)), SIGNAL(tick(qint32)));
+    connect(m_player.data(), SIGNAL(prefinishMarkReached(qint32)), SIGNAL(prefinishMarkReached(qint32)));
+    connect(m_player.data(), SIGNAL(prefinishMarkReached(qint32)), SLOT(handlePrefinishMarkReached(qint32)));
+    connect(m_player.data(), SIGNAL(tick(qint64)), SIGNAL(tick(qint64)));
 
     // We need to call setError() after doing the connects, otherwise the
     // error won't be received.
@@ -414,8 +415,20 @@ void MMF::MediaObject::switchToNextSource()
         m_nextSourceSet = false;
         switchToSource(m_nextSource);
         play();
+    } else {
+        emit finished();
     }
 }
 
+//-----------------------------------------------------------------------------
+// Other private functions
+//-----------------------------------------------------------------------------
+
+void MMF::MediaObject::handlePrefinishMarkReached(qint32 time)
+{
+    emit tick(time);
+}
+
+
 QT_END_NAMESPACE
 
diff --git a/src/3rdparty/phonon/mmf/mediaobject.h b/src/3rdparty/phonon/mmf/mediaobject.h
index 62e0a0e..f15eb21 100644
--- a/src/3rdparty/phonon/mmf/mediaobject.h
+++ b/src/3rdparty/phonon/mmf/mediaobject.h
@@ -107,6 +107,9 @@ Q_SIGNALS:
     void finished();
     void tick(qint64 time);
 
+private Q_SLOTS:
+    void handlePrefinishMarkReached(qint32);
+
 private:
     void switchToSource(const MediaSource &source);
     void createPlayer(const MediaSource &source);
diff --git a/src/3rdparty/phonon/mmf/videoplayer_dsa.cpp b/src/3rdparty/phonon/mmf/videoplayer_dsa.cpp
index d607f1d..1925471 100644
--- a/src/3rdparty/phonon/mmf/videoplayer_dsa.cpp
+++ b/src/3rdparty/phonon/mmf/videoplayer_dsa.cpp
@@ -226,38 +226,40 @@ void MMF::DsaVideoPlayer::handleParametersChanged(VideoParameters parameters)
     getDsaRegion(m_wsSession, *m_window);
 #endif
 
-    static const TBool antialias = ETrue;
-    int err = KErrNone;
-
-    if (parameters & ScaleFactors) {
-        TRAP(err, m_player->SetScaleFactorL(m_scaleWidth, m_scaleHeight,
-                                            antialias));
-        if(KErrNone != err) {
-            TRACE("SetScaleFactorL (1) err %d", err);
-            setError(tr("Video display error"), err);
+    if (m_player) {
+        static const TBool antialias = ETrue;
+        int err = KErrNone;
+
+        if (parameters & ScaleFactors) {
+            TRAP(err, m_player->SetScaleFactorL(m_scaleWidth, m_scaleHeight,
+                                                antialias));
+            if(KErrNone != err) {
+                TRACE("SetScaleFactorL (1) err %d", err);
+                setError(tr("Video display error"), err);
+            }
         }
-    }
 
-    if (KErrNone == err) {
-        if (parameters & WindowHandle || parameters & WindowScreenRect) {
-            TRAP(err,
-                m_player->SetDisplayWindowL(m_wsSession, m_screenDevice,
-                                            *m_window,
-                                            m_videoScreenRect,
-                                            m_videoScreenRect));
-        }
+        if (KErrNone == err) {
+            if (parameters & WindowHandle || parameters & WindowScreenRect) {
+                TRAP(err,
+                    m_player->SetDisplayWindowL(m_wsSession, m_screenDevice,
+                                                *m_window,
+                                                m_videoScreenRect,
+                                                m_videoScreenRect));
+            }
 
-        if (KErrNone != err) {
-            TRACE("SetDisplayWindowL err %d", err);
-            setError(tr("Video display error"), err);
-        } else {
-            m_dsaActive = true;
-            if (parameters & ScaleFactors) {
-                TRAP(err, m_player->SetScaleFactorL(m_scaleWidth, m_scaleHeight,
-                                                    antialias));
-                if (KErrNone != err) {
-                    TRACE("SetScaleFactorL (2) err %d", err);
-                    setError(tr("Video display error"), err);
+            if (KErrNone != err) {
+                TRACE("SetDisplayWindowL err %d", err);
+                setError(tr("Video display error"), err);
+            } else {
+                m_dsaActive = true;
+                if (parameters & ScaleFactors) {
+                    TRAP(err, m_player->SetScaleFactorL(m_scaleWidth, m_scaleHeight,
+                                                        antialias));
+                    if (KErrNone != err) {
+                        TRACE("SetScaleFactorL (2) err %d", err);
+                        setError(tr("Video display error"), err);
+                    }
                 }
             }
         }
@@ -296,7 +298,7 @@ bool MMF::DsaVideoPlayer::stopDirectScreenAccess()
 
     const bool dsaWasActive = m_dsaActive;
     if (m_dsaActive) {
-        TRAPD(err, m_player->StopDirectScreenAccessL());
+        TRAP(err, m_player->StopDirectScreenAccessL());
         if (KErrNone == err)
             m_dsaActive = false;
         else
diff --git a/src/3rdparty/phonon/mmf/videoplayer_surface.cpp b/src/3rdparty/phonon/mmf/videoplayer_surface.cpp
index 5f234e5..fda7342 100644
--- a/src/3rdparty/phonon/mmf/videoplayer_surface.cpp
+++ b/src/3rdparty/phonon/mmf/videoplayer_surface.cpp
@@ -104,44 +104,43 @@ void MMF::SurfaceVideoPlayer::handleVideoWindowChanged()
 
 void MMF::SurfaceVideoPlayer::handleParametersChanged(VideoParameters parameters)
 {
-    CVideoPlayerUtility2 *player = static_cast<CVideoPlayerUtility2 *>(m_player.data());
-
-    int err = KErrNone;
-
     TRect rect;
-
     if (m_videoOutput) {
         m_videoOutput->dump();
         const QSize size = m_videoOutput->videoWindowSize();
         rect.SetSize(TSize(size.width(), size.height()));
     }
 
-    if (parameters & WindowHandle) {
-        if (m_displayWindow)
-            player->RemoveDisplayWindow(*m_displayWindow);
-
-        RWindow *window = static_cast<RWindow *>(m_window);
-        if (window) {
-            window->SetBackgroundColor(TRgb(0, 0, 0, 255));
-            TRAP(err, player->AddDisplayWindowL(m_wsSession, m_screenDevice, *window, rect, rect));
-            if (KErrNone != err) {
-                setError(tr("Video display error"), err);
-                window = 0;
+    CVideoPlayerUtility2 *player = static_cast<CVideoPlayerUtility2 *>(m_player.data());
+    if (player) {
+        int err = KErrNone;
+        if (parameters & WindowHandle) {
+            if (m_displayWindow)
+                player->RemoveDisplayWindow(*m_displayWindow);
+
+            RWindow *window = static_cast<RWindow *>(m_window);
+            if (window) {
+                window->SetBackgroundColor(TRgb(0, 0, 0, 255));
+                TRAP(err, player->AddDisplayWindowL(m_wsSession, m_screenDevice, *window, rect, rect));
+                if (KErrNone != err) {
+                    setError(tr("Video display error"), err);
+                    window = 0;
+                }
             }
+            m_displayWindow = window;
         }
-        m_displayWindow = window;
-    }
 
-    if (KErrNone == err) {
-        if (parameters & ScaleFactors) {
-            Q_ASSERT(m_displayWindow);
-            TRAP(err, player->SetVideoExtentL(*m_displayWindow, rect));
-            if (KErrNone == err)
-                TRAP(err, player->SetWindowClipRectL(*m_displayWindow, rect));
-            if (KErrNone == err)
-                TRAP(err, player->SetScaleFactorL(*m_displayWindow, m_scaleWidth, m_scaleHeight));
-            if (KErrNone != err)
-                setError(tr("Video display error"), err);
+        if (KErrNone == err) {
+            if (parameters & ScaleFactors) {
+                Q_ASSERT(m_displayWindow);
+                TRAP(err, player->SetVideoExtentL(*m_displayWindow, rect));
+                if (KErrNone == err)
+                    TRAP(err, player->SetWindowClipRectL(*m_displayWindow, rect));
+                if (KErrNone == err)
+                    TRAP(err, player->SetScaleFactorL(*m_displayWindow, m_scaleWidth, m_scaleHeight));
+                if (KErrNone != err)
+                    setError(tr("Video display error"), err);
+            }
         }
     }
 }