[WebKitLegacy] Media playback pauses on scroll
[WebKit-https.git] / Source / WebCore / platform / audio / PlatformMediaSession.h
index 09c6ec2..25c1779 100644 (file)
@@ -26,8 +26,8 @@
 #ifndef PlatformMediaSession_h
 #define PlatformMediaSession_h
 
-#include "MediaProducer.h"
 #include "Timer.h"
+#include <wtf/LoggerHelper.h>
 #include <wtf/Noncopyable.h>
 #include <wtf/text/WTFString.h>
 
@@ -45,7 +45,11 @@ class PlatformMediaSession
 #if ENABLE(WIRELESS_PLAYBACK_TARGET)
     : public MediaPlaybackTargetClient
 #endif
+#if !RELEASE_LOG_DISABLED
+    , private LoggerHelper
+#endif
 {
+    WTF_MAKE_FAST_ALLOCATED;
 public:
     static std::unique_ptr<PlatformMediaSession> create(PlatformMediaSessionClient&);
 
@@ -55,8 +59,10 @@ public:
     enum MediaType {
         None = 0,
         Video,
+        VideoAudio,
         Audio,
         WebAudio,
+        MediaStreamCapturingAudio,
     };
     MediaType mediaType() const;
     MediaType presentationType() const;
@@ -78,6 +84,8 @@ public:
         SystemInterruption,
         SuspendedUnderLock,
         InvisibleAutoplay,
+        ProcessInactive,
+        PlaybackSuspended,
     };
     InterruptionType interruptionType() const { return m_interruptionType; }
 
@@ -99,21 +107,24 @@ public:
     void beginInterruption(InterruptionType);
     void endInterruption(EndInterruptionFlags);
 
-    void clientWillBeginAutoplaying();
-    bool clientWillBeginPlayback();
-    bool clientWillPausePlayback();
+    virtual void clientWillBeginAutoplaying();
+    virtual bool clientWillBeginPlayback();
+    virtual bool clientWillPausePlayback();
 
     void pauseSession();
     void stopSession();
     
-    void visibilityChanged();
-
 #if ENABLE(VIDEO)
+    uint64_t uniqueIdentifier() const;
     String title() const;
     double duration() const;
     double currentTime() const;
 #endif
 
+    typedef union {
+        double asDouble;
+    } RemoteCommandArgument;
+
     enum RemoteControlCommandType {
         NoCommand,
         PlayCommand,
@@ -124,9 +135,11 @@ public:
         EndSeekingBackwardCommand,
         BeginSeekingForwardCommand,
         EndSeekingForwardCommand,
+        SeekToPlaybackPositionCommand,
     };
     bool canReceiveRemoteControlCommands() const;
-    void didReceiveRemoteControlCommand(RemoteControlCommandType);
+    void didReceiveRemoteControlCommand(RemoteControlCommandType, const RemoteCommandArgument* argument = nullptr);
+    bool supportsSeeking() const;
 
     enum DisplayType {
         Normal,
@@ -136,8 +149,10 @@ public:
     DisplayType displayType() const;
 
     bool isHidden() const;
+    bool isSuspended() const;
+
+    bool shouldOverrideBackgroundLoadingRestriction() const;
 
-    virtual bool canPlayToWirelessPlaybackTarget() const { return false; }
     virtual bool isPlayingToWirelessPlaybackTarget() const { return m_isPlayingToWirelessPlaybackTarget; }
     void isPlayingToWirelessPlaybackTargetChanged(bool);
 
@@ -148,30 +163,46 @@ public:
     void setShouldPlayToPlaybackTarget(bool) override { }
 #endif
 
-#if PLATFORM(IOS)
+#if PLATFORM(IOS_FAMILY)
     virtual bool requiresPlaybackTargetRouteMonitoring() const { return false; }
 #endif
 
     bool activeAudioSessionRequired();
-    bool canProduceAudio() const { return m_canProduceAudio; }
-    void setCanProduceAudio(bool);
+    bool canProduceAudio() const;
+    void canProduceAudioChanged();
+
+    virtual void resetPlaybackSessionState() { }
+    String sourceApplicationIdentifier() const;
+
+    virtual bool allowsNowPlayingControlsVisibility() const { return false; }
+
+    bool hasPlayedSinceLastInterruption() const { return m_hasPlayedSinceLastInterruption; }
+    void clearHasPlayedSinceLastInterruption() { m_hasPlayedSinceLastInterruption = false; }
 
 protected:
     PlatformMediaSessionClient& client() const { return m_client; }
 
-private:
-    void clientDataBufferingTimerFired();
-    void updateClientDataBuffering();
+#if !RELEASE_LOG_DISABLED
+    const Logger& logger() const final { return m_logger.get(); }
+    const void* logIdentifier() const override { return reinterpret_cast<const void*>(m_logIdentifier); }
+    const char* logClassName() const override { return "PlatformMediaSession"; }
+    WTFLogChannel& logChannel() const final;
+#endif
 
+private:
     PlatformMediaSessionClient& m_client;
-    Timer m_clientDataBufferingTimer;
     State m_state;
     State m_stateToRestore;
     InterruptionType m_interruptionType { NoInterruption };
     int m_interruptionCount { 0 };
     bool m_notifyingClient;
     bool m_isPlayingToWirelessPlaybackTarget { false };
-    bool m_canProduceAudio { false };
+    bool m_hasPlayedSinceLastInterruption { false };
+
+#if !RELEASE_LOG_DISABLED
+    Ref<const Logger> m_logger;
+    uint64_t m_logIdentifier;
+#endif
 
     friend class PlatformMediaSessionManager;
 };
@@ -179,7 +210,7 @@ private:
 class PlatformMediaSessionClient {
     WTF_MAKE_NONCOPYABLE(PlatformMediaSessionClient);
 public:
-    PlatformMediaSessionClient() { }
+    PlatformMediaSessionClient() = default;
     
     virtual PlatformMediaSession::MediaType mediaType() const = 0;
     virtual PlatformMediaSession::MediaType presentationType() const = 0;
@@ -191,31 +222,72 @@ public:
     virtual void suspendPlayback() = 0;
 
 #if ENABLE(VIDEO)
+    virtual uint64_t mediaSessionUniqueIdentifier() const;
     virtual String mediaSessionTitle() const;
     virtual double mediaSessionDuration() const;
     virtual double mediaSessionCurrentTime() const;
 #endif
     
     virtual bool canReceiveRemoteControlCommands() const = 0;
-    virtual void didReceiveRemoteControlCommand(PlatformMediaSession::RemoteControlCommandType) = 0;
+    virtual void didReceiveRemoteControlCommand(PlatformMediaSession::RemoteControlCommandType, const PlatformMediaSession::RemoteCommandArgument*) = 0;
+    virtual bool supportsSeeking() const = 0;
 
-    virtual void setShouldBufferData(bool) { }
-    virtual bool elementIsHidden() const { return false; }
+    virtual bool canProduceAudio() const { return false; }
+    virtual bool isSuspended() const { return false; };
 
     virtual bool shouldOverrideBackgroundPlaybackRestriction(PlatformMediaSession::InterruptionType) const = 0;
+    virtual bool shouldOverrideBackgroundLoadingRestriction() const { return false; }
 
     virtual void wirelessRoutesAvailableDidChange() { }
     virtual void setWirelessPlaybackTarget(Ref<MediaPlaybackTarget>&&) { }
-    virtual bool canPlayToWirelessPlaybackTarget() const { return false; }
     virtual bool isPlayingToWirelessPlaybackTarget() const { return false; }
     virtual void setShouldPlayToPlaybackTarget(bool) { }
 
-    virtual const Document* hostingDocument() const = 0;
+    virtual bool isPlayingOnSecondScreen() const { return false; }
+
+    virtual Document* hostingDocument() const = 0;
+    virtual String sourceApplicationIdentifier() const = 0;
+
+    virtual bool processingUserGestureForMedia() const = 0;
 
 protected:
-    virtual ~PlatformMediaSessionClient() { }
+    virtual ~PlatformMediaSessionClient() = default;
 };
 
+String convertEnumerationToString(PlatformMediaSession::State);
+String convertEnumerationToString(PlatformMediaSession::InterruptionType);
+String convertEnumerationToString(PlatformMediaSession::RemoteControlCommandType);
 }
 
+namespace WTF {
+
+template<typename Type>
+struct LogArgument;
+
+template <>
+struct LogArgument<WebCore::PlatformMediaSession::State> {
+    static String toString(const WebCore::PlatformMediaSession::State state)
+    {
+        return convertEnumerationToString(state);
+    }
+};
+
+template <>
+struct LogArgument<WebCore::PlatformMediaSession::InterruptionType> {
+    static String toString(const WebCore::PlatformMediaSession::InterruptionType state)
+    {
+        return convertEnumerationToString(state);
+    }
+};
+
+template <>
+struct LogArgument<WebCore::PlatformMediaSession::RemoteControlCommandType> {
+    static String toString(const WebCore::PlatformMediaSession::RemoteControlCommandType command)
+    {
+        return convertEnumerationToString(command);
+    }
+};
+
+} // namespace WTF
+
 #endif // PlatformMediaSession_h