Eliminate MediaPlayer & MediaPlayerClient abstractions

Source/core/html/HTMLMediaElement.h

 /*
  * Copyright (C) 2007, 2008, 2009, 2010, 2011, 2012, 2013 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
@@ skipping 14 matching lines @@
 
 #ifndef HTMLMediaElement_h
 #define HTMLMediaElement_h
 
 #include "core/CoreExport.h"
 #include "core/dom/ActiveDOMObject.h"
 #include "core/events/GenericEventQueue.h"
 #include "core/html/HTMLElement.h"
 #include "core/html/track/TextTrack.h"
 #include "platform/Supplementable.h"
-#include "platform/graphics/media/MediaPlayer.h"
+#include "platform/audio/AudioSourceProvider.h"
+#include "public/platform/WebAudioSourceProviderClient.h"
 #include "public/platform/WebMediaPlayerClient.h"
 #include "public/platform/WebMimeRegistry.h"
 
 namespace blink {
 class WebInbandTextTrack;
 class WebLayer;
 }
 
 namespace blink {
 
@@ skipping 12 matching lines @@
 class MediaController;
 class MediaControls;
 class MediaError;
 class HTMLMediaSource;
 class TextTrackContainer;
 class TextTrackList;
 class TimeRanges;
 class URLRegistry;
 class VideoTrackList;
 
-// FIXME: The inheritance from MediaPlayerClient here should be private inheritance.
-// But it can't be until the Chromium WebMediaPlayerClientImpl class is fixed so it
-// no longer depends on typecasting a MediaPlayerClient to an HTMLMediaElement.
-
-class CORE_EXPORT HTMLMediaElement : public HTMLElement, public WillBeHeapSupplementable<HTMLMediaElement>, public MediaPlayerClient, public ActiveDOMObject {
+class CORE_EXPORT HTMLMediaElement : public HTMLElement, public WillBeHeapSupplementable<HTMLMediaElement>, public WebMediaPlayerClient, public ActiveDOMObject {
     DEFINE_WRAPPERTYPEINFO();
     WILL_BE_USING_GARBAGE_COLLECTED_MIXIN(HTMLMediaElement);
 public:
     static WebMimeRegistry::SupportsType supportsType(const ContentType&, const String& keySystem = String());
 
     static void setMediaStreamRegistry(URLRegistry*);
     static bool isMediaStreamURL(const String& url);
 
     DECLARE_VIRTUAL_TRACE();
 #if ENABLE(WEB_AUDIO)
     void clearWeakMembers(Visitor*);
 #endif
-    WebMediaPlayer* webMediaPlayer() const { return m_player ? m_player->webMediaPlayer() : 0; }
+    WebMediaPlayer* webMediaPlayer() const
+    {
+        return m_webMediaPlayer.get();
+    }
 
     virtual bool hasVideo() const { return false; }
     bool hasAudio() const;
 
     bool supportsSave() const;
 
     WebLayer* platformLayer() const;
 
     enum DelayedActionType {
         LoadMediaResource = 1 << 0,
         LoadTextTrackResource = 1 << 1,
         TextTrackChangesNotification = 1 << 2
     };
     void scheduleDelayedAction(DelayedActionType);
 
     bool hasRemoteRoutes() const { return m_remoteRoutesAvailable; }
     bool isPlayingRemotely() const { return m_playingRemotely; }
 
     // error state
     PassRefPtrWillBeRawPtr<MediaError> error() const;
 
     // network state
     void setSrc(const AtomicString&);
     const KURL& currentSrc() const { return m_currentSrc; }
 
     enum NetworkState { NETWORK_EMPTY, NETWORK_IDLE, NETWORK_LOADING, NETWORK_NO_SOURCE };
     NetworkState networkState() const;
 
     String preload() const;
-    MediaPlayer::Preload effectivePreloadType() const;
+    WebMediaPlayer::Preload effectivePreloadType() const;
     void setPreload(const AtomicString&);
 
     PassRefPtrWillBeRawPtr<TimeRanges> buffered() const;
     void load();
     String canPlayType(const String& mimeType, const String& keySystem = String()) const;
 
     // ready state
     enum ReadyState { HAVE_NOTHING, HAVE_METADATA, HAVE_CURRENT_DATA, HAVE_FUTURE_DATA, HAVE_ENOUGH_DATA };
     ReadyState readyState() const;
     bool seeking() const;
@@ skipping 18 matching lines @@
     void pause();
     void requestRemotePlayback();
     void requestRemotePlaybackControl();
 
     // statistics
     unsigned webkitAudioDecodedByteCount() const;
     unsigned webkitVideoDecodedByteCount() const;
 
     // media source extensions
     void closeMediaSource();
-    void durationChanged(double duration, bool requestSeek);
+    void mediaPlayerDurationChanged(double duration, bool requestSeek);
 
     // controls
     bool shouldShowControls() const;
     double volume() const;
     void setVolume(double, ExceptionState&);
     bool muted() const;
     void setMuted(bool);
 
     // play/pause toggling that uses the media controller if present. togglePlayStateWillPlay() is
     // true if togglePlayState() will call play() or unpause() on the media element or controller.
     bool togglePlayStateWillPlay() const;
     void togglePlayState();
 
     AudioTrackList& audioTracks();
     void audioTrackChanged();
 
     VideoTrackList& videoTracks();
     void selectedVideoTrackChanged(WebMediaPlayer::TrackId*);
 
     PassRefPtrWillBeRawPtr<TextTrack> addTextTrack(const AtomicString& kind, const AtomicString& label, const AtomicString& language, ExceptionState&);
 
     TextTrackList* textTracks();
     CueTimeline& cueTimeline();
 
-    void addTextTrack(TextTrack*);
-    void removeTextTrack(TextTrack*);
+    void mediaPlayerAddTextTrack(TextTrack*);
+    void mediaPlayerRemoveTextTrack(TextTrack*);
     void textTracksChanged();
     void notifyMediaPlayerOfTextTrackChanges();
 
     // Implements the "forget the media element's media-resource-specific tracks" algorithm in the HTML5 spec.
     void forgetResourceSpecificTracks();
 
     void didAddTrackElement(HTMLTrackElement*);
     void didRemoveTrackElement(HTMLTrackElement*);
 
-    WebMediaPlayer::TrackId addAudioTrack(const String& id, WebMediaPlayerClient::AudioTrackKind, const AtomicString& label, const AtomicString& language, bool enabled);
-    void removeAudioTrack(WebMediaPlayer::TrackId);
-    WebMediaPlayer::TrackId addVideoTrack(const String& id, WebMediaPlayerClient::VideoTrackKind, const AtomicString& label, const AtomicString& language, bool selected);
-    void removeVideoTrack(WebMediaPlayer::TrackId);
-
-    virtual void mediaPlayerDidAddTextTrack(WebInbandTextTrack*) override final;
-    virtual void mediaPlayerDidRemoveTextTrack(WebInbandTextTrack*) override final;
     // FIXME: Remove this when WebMediaPlayerClientImpl::loadInternal does not depend on it.
-    virtual KURL mediaPlayerPosterURL() override { return KURL(); }
+    virtual KURL mediaPlayerPosterURL() { return KURL(); }
 
     void honorUserPreferencesForAutomaticTextTrackSelection();
 
     bool textTracksAreReady() const;
     enum VisibilityChangeAssumption {
         AssumeNoVisibleChange,
         AssumeVisibleChange
     };
     void configureTextTrackDisplay(VisibilityChangeAssumption);
     void updateTextTrackDisplay();
     double lastSeekTime() const { return m_lastSeekTime; }
     void textTrackReadyStateChanged(TextTrack*);
 
     void textTrackModeChanged(TextTrack*);
 
     // EventTarget function.
     // Both Node (via HTMLElement) and ActiveDOMObject define this method, which
     // causes an ambiguity error at compile time. This class's constructor
     // ensures that both implementations return document, so return the result
     // of one of them here.
     using HTMLElement::executionContext;
 
-    bool hasSingleSecurityOrigin() const { return !m_player || (webMediaPlayer() && webMediaPlayer()->hasSingleSecurityOrigin()); }
+    bool hasSingleSecurityOrigin() const { return webMediaPlayer() && webMediaPlayer()->hasSingleSecurityOrigin(); }
 
     bool isFullscreen() const;
 
     bool hasClosedCaptions() const;
     bool closedCaptionsVisible() const;
     void setClosedCaptionsVisible(bool);
 
-    void remoteRouteAvailabilityChanged(bool);
-    void connectedToRemoteDevice();
-    void disconnectedFromRemoteDevice();
-
     // Returns the MediaControls, or null if they have not been added yet.
     // Note that this can be non-null even if there is no controls attribute.
     MediaControls* mediaControls() const;
 
     // Notifies the media element that the media controls became visible, so
     // that text track layout may be updated to avoid overlapping them.
     void mediaControlsDidBecomeVisible();
 
     void sourceWasRemoved(HTMLSourceElement*);
     void sourceWasAdded(HTMLSourceElement*);
@@ skipping 78 matching lines @@
     virtual void defaultEventHandler(Event*) override final;
 
     // ActiveDOMObject functions.
     virtual void stop() override final;
 
     virtual void updateDisplayState() { }
 
     void setReadyState(ReadyState);
     void setNetworkState(WebMediaPlayer::NetworkState);
 
-    virtual void mediaPlayerNetworkStateChanged() override final;
-    virtual void mediaPlayerReadyStateChanged() override final;
-    virtual void mediaPlayerTimeChanged() override final;
-    virtual void mediaPlayerDurationChanged() override final;
-    virtual void mediaPlayerPlaybackStateChanged() override final;
+    virtual void networkStateChanged() override final;
+    virtual void readyStateChanged() override final;
+    virtual void timeChanged() override final;
+    virtual void repaint() override final;
+    virtual void durationChanged() override final;
+    virtual void sizeChanged() override final;
+    virtual void playbackStateChanged() override final;
+
+    virtual void setWebLayer(WebLayer*) override final;
+    virtual WebMediaPlayer::TrackId addAudioTrack(const WebString&, WebMediaPlayerClient::AudioTrackKind, const WebString&, const WebString&, bool) override final;
+    virtual void removeAudioTrack(WebMediaPlayer::TrackId) override final;
+    virtual WebMediaPlayer::TrackId addVideoTrack(const WebString&, WebMediaPlayerClient::VideoTrackKind, const WebString&, const WebString&, bool) override final;
+    virtual void removeVideoTrack(WebMediaPlayer::TrackId) override final;
+    virtual void addTextTrack(WebInbandTextTrack*) override final;
+    virtual void removeTextTrack(WebInbandTextTrack*) override final;
+    virtual void mediaSourceOpened(WebMediaSource*) override final;
     virtual void mediaPlayerRequestFullscreen() override final;
     virtual void mediaPlayerRequestSeek(double) override final;
-    virtual void mediaPlayerRepaint() override final;
-    virtual void mediaPlayerSizeChanged() override final;
-    virtual void mediaPlayerSetWebLayer(WebLayer*) override final;
-    virtual void mediaPlayerMediaSourceOpened(WebMediaSource*) override final;
+    virtual void remoteRouteAvailabilityChanged(bool) override final;
+    virtual void connectedToRemoteDevice() override final;
+    virtual void disconnectedFromRemoteDevice() override final;
 
     void loadTimerFired(Timer<HTMLMediaElement>*);
     void progressEventTimerFired(Timer<HTMLMediaElement>*);
     void playbackProgressTimerFired(Timer<HTMLMediaElement>*);
     void startPlaybackProgressTimer();
     void startProgressEventTimer();
     void stopPeriodicTimers();
 
     void seek(double time);
     void finishSeek();
@@ skipping 91 matching lines @@
     // addAudioTrack() and addVideoTrack().
     // FIXME: Remove this once all WebMediaPlayer implementations properly report their track info.
     void createPlaceholderTracksIfNecessary();
 
     // Sets the selected/enabled tracks if they aren't set before we initially
     // transition to HAVE_METADATA.
     void selectInitialTracksIfNecessary();
 
     void audioTracksTimerFired(Timer<HTMLMediaElement>*);
 
+    void prepareAndLoadMediaPlayer(const WTF::String& url);
+
     Timer<HTMLMediaElement> m_loadTimer;
     Timer<HTMLMediaElement> m_progressEventTimer;
     Timer<HTMLMediaElement> m_playbackProgressTimer;
     Timer<HTMLMediaElement> m_audioTracksTimer;
     RefPtrWillBeMember<TimeRanges> m_playedTimeRanges;
     OwnPtrWillBeMember<GenericEventQueue> m_asyncEventQueue;
 
     double m_playbackRate;
     double m_defaultPlaybackRate;
     NetworkState m_networkState;
@@ skipping 35 matching lines @@
         WaitingForStopDelayingLoadEventTask,
         // The load is the deferred, and waiting for a triggering event.
         WaitingForTrigger,
         // The load is deferred, and waiting for the task to set the
         // delaying-the-load-event flag, after which the load will be executed.
         ExecuteOnStopDelayingLoadEventTask
     };
     DeferredLoadState m_deferredLoadState;
     Timer<HTMLMediaElement> m_deferredLoadTimer;
 
-    OwnPtr<MediaPlayer> m_player;
+    OwnPtr<WebMediaPlayer> m_webMediaPlayer;
     WebLayer* m_webLayer;
 
-    MediaPlayer::Preload m_preload;
+    WebMediaPlayer::Preload m_preload;
 
     DisplayMode m_displayMode;
 
     RefPtrWillBeMember<HTMLMediaSource> m_mediaSource;
 
     // Cached time value. Only valid when ready state is HAVE_METADATA or
     // higher, otherwise the current time is assumed to be zero.
     mutable double m_cachedTime;
 
     double m_fragmentEndTime;
@@ skipping 40 matching lines @@
     RefPtrWillBeMember<TextTrackList> m_textTracks;
     WillBeHeapVector<RefPtrWillBeMember<TextTrack>> m_textTracksWhenResourceSelectionBegan;
 
     OwnPtrWillBeMember<CueTimeline> m_cueTimeline;
 
 #if ENABLE(WEB_AUDIO)
     // This is a weak reference, since m_audioSourceNode holds a reference to us.
     // FIXME: Oilpan: Consider making this a strongly traced pointer with oilpan where strong cycles are not a problem.
     GC_PLUGIN_IGNORE("http://crbug.com/404577")
     RawPtrWillBeWeakMember<AudioSourceProviderClient> m_audioSourceNode;
+
+    // AudioClientImpl wraps an AudioSourceProviderClient.
+    // When the audio format is known, Chromium calls setFormat().
+
+    class AudioClientImpl final : public GarbageCollectedFinalized<AudioClientImpl>, public WebAudioSourceProviderClient {
+    public:
+        explicit AudioClientImpl(AudioSourceProviderClient* client)
+            : m_client(client)
+        {
+        }
+
+        virtual ~AudioClientImpl() { }
+
+        // WebAudioSourceProviderClient
+        virtual void setFormat(size_t numberOfChannels, float sampleRate) override;
+
+        DECLARE_TRACE();
+
+    private:
+        Member<AudioSourceProviderClient> m_client;
+    };
+
+    // AudioSourceProviderImpl wraps a WebAudioSourceProvider.
+    // provideInput() calls into Chromium to get a rendered audio stream.
+
+    class AudioSourceProviderImpl final : public AudioSourceProvider {
+    public:
+        AudioSourceProviderImpl()
+            : m_webAudioSourceProvider(0)
+        {
+        }
+
+        virtual ~AudioSourceProviderImpl() { }
+
+        // Wraps the given WebAudioSourceProvider.
+        void wrap(WebAudioSourceProvider*);
+
+        // AudioSourceProvider
+        virtual void setClient(AudioSourceProviderClient*) override;
+        virtual void provideInput(AudioBus*, size_t framesToProcess) override;
+
+    private:
+        WebAudioSourceProvider* m_webAudioSourceProvider;
+        Persistent<AudioClientImpl> m_client;
+        Mutex provideInputLock;
+    };
+
+    AudioSourceProviderImpl m_audioSourceProvider;
 #endif
 
     friend class MediaController;
     RefPtrWillBeMember<MediaController> m_mediaController;
 
     friend class Internals;
     friend class TrackDisplayUpdateScope;
 
     static URLRegistry* s_mediaStreamRegistry;
 };
 
 inline bool isHTMLMediaElement(const HTMLElement& element)
 {
     return isHTMLAudioElement(element) || isHTMLVideoElement(element);
 }
 
 DEFINE_HTMLELEMENT_TYPE_CASTS_WITH_FUNCTION(HTMLMediaElement);
 
 } // namespace blink
 
 #endif // HTMLMediaElement_h