Attachment #240105 for bug #137765

View Details Raw Unified Return to Bug 137765

| Differences between



2014-10-20  Gyuyoung Kim  <gyuyoung.kim@samsung.com>

        Use std::unique_ptr instead of PassOwnPtr in MediaPlayerFoo classes
        https://bugs.webkit.org/show_bug.cgi?id=137765

        Reviewed by NOBODY (OOPS!).

        As a step to use std::unique_ptr|make_unique<>, this patch changes use of OwnPtr|PassOwnPtr with
        std::unique_ptr<>|make_unique<>. However we have to set constructor to public in order to use
        std::make_unique<>. This change will conflict with MediaPlayerFoo's create() factory function
        because there are two object creation methods. Thus this patch removes create() factory function
        in MediaPlayerFoo classes and also lets MediaPlayerFactory create MediaPlayerFoo using std::make_unique<>
        instead of the create() factory functions.

        No new tests, no behavior changes.

        * html/HTMLMediaElement.cpp:
        (WebCore::HTMLMediaElement::parseAttribute):
        * html/HTMLMediaElement.h:
        * platform/graphics/MediaEnginePlayerType.h: Added.
        * platform/graphics/MediaPlayer.cpp:
        (WebCore::NullMediaPlayerPrivate::NullMediaPlayerPrivate):
        (WebCore::MediaPlayerFactory::MediaPlayerFactory):
        (WebCore::MediaPlayerFactory::createMediaPlayer):
        (WebCore::addMediaEngine):
        (WebCore::MediaPlayer::MediaPlayer):
        (WebCore::MediaPlayer::loadWithNextMediaEngine):
        (WebCore::createNullMediaPlayer): Deleted.
        * platform/graphics/MediaPlayer.h:
        (WebCore::MediaPlayer::create): Deleted.
        * platform/graphics/avfoundation/MediaPlayerPrivateAVFoundation.h:
        * platform/graphics/avfoundation/cf/MediaPlayerPrivateAVFoundationCF.cpp:
        (WebCore::MediaPlayerPrivateAVFoundationCF::registerMediaEngine):
        (WebCore::MediaPlayerPrivateAVFoundationCF::create): Deleted.
        * platform/graphics/avfoundation/cf/MediaPlayerPrivateAVFoundationCF.h:
        * platform/graphics/avfoundation/objc/MediaPlayerPrivateAVFoundationObjC.h:
        * platform/graphics/avfoundation/objc/MediaPlayerPrivateAVFoundationObjC.mm:
        (WebCore::MediaPlayerPrivateAVFoundationObjC::registerMediaEngine):
        (WebCore::MediaPlayerPrivateAVFoundationObjC::create): Deleted.
        * platform/graphics/avfoundation/objc/MediaPlayerPrivateMediaSourceAVFObjC.h:
        * platform/graphics/avfoundation/objc/MediaPlayerPrivateMediaSourceAVFObjC.mm:
        (WebCore::MediaPlayerPrivateMediaSourceAVFObjC::registerMediaEngine):
        (WebCore::MediaPlayerPrivateMediaSourceAVFObjC::create): Deleted.
        * platform/graphics/gstreamer/MediaPlayerPrivateGStreamer.cpp:
        (WebCore::MediaPlayerPrivateGStreamer::registerMediaEngine):
        (WebCore::MediaPlayerPrivateGStreamer::create): Deleted.
        * platform/graphics/gstreamer/MediaPlayerPrivateGStreamer.h:
        * platform/graphics/mac/MediaPlayerPrivateQTKit.h:
        * platform/graphics/mac/MediaPlayerPrivateQTKit.mm:
        (WebCore::MediaPlayerPrivateQTKit::registerMediaEngine):
        (WebCore::MediaPlayerPrivateQTKit::create): Deleted.
        * platform/graphics/win/MediaPlayerPrivateMediaFoundation.cpp:
        (WebCore::MediaPlayerPrivateMediaFoundation::registerMediaEngine):
        (WebCore::MediaPlayerPrivateMediaFoundation::create): Deleted.
        * platform/graphics/win/MediaPlayerPrivateMediaFoundation.h:
        * platform/mock/mediasource/MockMediaPlayerMediaSource.cpp:
        (WebCore::MockMediaPlayerMediaSource::registerMediaEngine):
        (WebCore::MockMediaPlayerMediaSource::create): Deleted.
        * platform/mock/mediasource/MockMediaPlayerMediaSource.h:

2014-10-19  Chris Dumez  <cdumez@apple.com>

        Use is<>() / downcast<>() for all remaining RenderObject subclasses



        m_mediaSession->setHasPlaybackTargetAvailabilityListeners(*this, false);
#endif

    m_player = nullptr;

    stopPeriodicTimers();
    m_loadTimer.stop();

    // Once an active DOM object has been stopped it can not be restarted, so we can deallocate
    // the media player now. Note that userCancelledLoad will already have cleared the player
    // if the media was not fully loaded. This handles all other cases.
    m_player = nullptr;

    updateSleepDisabling();
}

#if ENABLE(VIDEO_TRACK)
    forgetResourceSpecificTracks();
#endif
    m_player = std::make_unique<MediaPlayer>(static_cast<MediaPlayerClient&>(*this));

#if ENABLE(WEB_AUDIO)
    if (m_audioSourceNode) {

Lines 770-776 private: a/Source/WebCore/html/HTMLMediaElement.h_sec1
- a/Source/WebCore/html/HTMLMediaElement.h -1 / +1 lines
770	MediaPlayer::VideoGravity m_videoFullscreenGravity;	770	MediaPlayer::VideoGravity m_videoFullscreenGravity;
771	#endif	771	#endif
772		772
773	OwnPtr<MediaPlayer> m_player;	773	std::unique_ptr<MediaPlayer> m_player;
774		774
775	MediaPlayer::Preload m_preload;	775	MediaPlayer::Preload m_preload;
776		776



/*
 * Copyright (C) 2014 Samsung Electronics.  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 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 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. 
 */


#ifndef MediaEnginePlayerType_h
#define MediaEnginePlayerType_h

namespace WebCore {
typedef enum {
    NullMediaPlayer,
    AVFoundationCFPlayer,
    AVFoundationObjCPlayer,
    MediaSourceAVFObjCPlayer,
    GStreamerPlayer,
    QTKitPlayer,
    MediaFoundationPlayer,
    MockMediaSourcePlayer
}  MediaEnginePlayerType;
}

#endif




class NullMediaPlayerPrivate : public MediaPlayerPrivateInterface {
public:
    explicit NullMediaPlayerPrivate(MediaPlayer*) { }

    virtual void load(const String&) { }
#if ENABLE(MEDIA_SOURCE)

#endif
};

static PassOwnPtr<MediaPlayerPrivateInterface> createNullMediaPlayer(MediaPlayer* player) 
{ 
    return adoptPtr(new NullMediaPlayerPrivate(player)); 
}


// engine support

struct MediaPlayerFactory {
    WTF_MAKE_NONCOPYABLE(MediaPlayerFactory); WTF_MAKE_FAST_ALLOCATED;
public:
    MediaPlayerFactory(MediaEnginePlayerType playerType, MediaEngineSupportedTypes getSupportedTypes, MediaEngineSupportsType supportsTypeAndCodecs,
        MediaEngineGetSitesInMediaCache getSitesInMediaCache, MediaEngineClearMediaCache clearMediaCache, MediaEngineClearMediaCacheForSite clearMediaCacheForSite, MediaEngineSupportsKeySystem supportsKeySystem)
            : playerType(playerType)
            , getSupportedTypes(getSupportedTypes)
            , supportsTypeAndCodecs(supportsTypeAndCodecs)
            , getSitesInMediaCache(getSitesInMediaCache)
            , clearMediaCache(clearMediaCache)
            , clearMediaCacheForSite(clearMediaCacheForSite)
            , supportsKeySystem(supportsKeySystem)
    {
    }

    MediaEnginePlayerType playerType;
    MediaEngineSupportedTypes getSupportedTypes;
    MediaEngineSupportsType supportsTypeAndCodecs;
    MediaEngineGetSitesInMediaCache getSitesInMediaCache;
    MediaEngineClearMediaCache clearMediaCache;
    MediaEngineClearMediaCacheForSite clearMediaCacheForSite;
    MediaEngineSupportsKeySystem supportsKeySystem;

    std::unique_ptr<MediaPlayerPrivateInterface> createMediaPlayer(MediaPlayer* player)
    {
        switch (playerType) {
        case NullMediaPlayer:
            return std::make_unique<NullMediaPlayerPrivate>(player);
#if PLATFORM(WIN) && ENABLE(VIDEO) && USE(AVFOUNDATION)
        case AVFoundationCFPlayer:
            return std::make_unique<MediaPlayerPrivateAVFoundationCF>(player);
#endif
#if ENABLE(VIDEO) && USE(AVFOUNDATION)
        case AVFoundationObjCPlayer:
            return std::make_unique<MediaPlayerPrivateAVFoundationObjC>(player);
#endif
#if ENABLE(MEDIA_SOURCE) && USE(AVFOUNDATION)
        case MediaSourceAVFObjCPlayer:
            return std::make_unique<MediaPlayerPrivateMediaSourceAVFObjC>(player);
#endif
#if ENABLE(VIDEO) && USE(GSTREAMER)
        case GStreamerPlayer:
            return std::make_unique<MediaPlayerPrivateGStreamer>(player);
#endif
#if ENABLE(VIDEO) && PLATFORM(MAC)
        case QTKitPlayer:
            return std::make_unique<MediaPlayerPrivateQTKit>(player);
#endif
#if USE(MEDIA_FOUNDATION)
        case MediaFoundationPlayer:
            return std::make_unique<MediaPlayerPrivateMediaFoundation>(player);
#endif
#if ENABLE(MEDIA_SOURCE)
        case MockMediaSourcePlayer:
            return std::make_unique<MockMediaPlayerMediaSource>(player);
#endif
        default:
            ASSERT_NOT_REACHED();
            return std::make_unique<NullMediaPlayerPrivate>(player);
        }
    }
};

static void addMediaEngine(MediaEnginePlayerType, MediaEngineSupportedTypes, MediaEngineSupportsType, MediaEngineGetSitesInMediaCache, MediaEngineClearMediaCache, MediaEngineClearMediaCacheForSite, MediaEngineSupportsKeySystem);

static MediaPlayerFactory* bestMediaEngineForSupportParameters(const MediaEngineSupportParameters&, MediaPlayerFactory* current = 0);
static MediaPlayerFactory* nextMediaEngine(MediaPlayerFactory* current);

    return installedEngines;
}

static void addMediaEngine(MediaEnginePlayerType playerType, MediaEngineSupportedTypes getSupportedTypes, MediaEngineSupportsType supportsType,
    MediaEngineGetSitesInMediaCache getSitesInMediaCache, MediaEngineClearMediaCache clearMediaCache, MediaEngineClearMediaCacheForSite clearMediaCacheForSite, MediaEngineSupportsKeySystem supportsKeySystem)
{
    ASSERT(playerType);
    ASSERT(getSupportedTypes);
    ASSERT(supportsType);

    installedMediaEngines().append(new MediaPlayerFactory(playerType, getSupportedTypes, supportsType, getSitesInMediaCache, clearMediaCache, clearMediaCacheForSite, supportsKeySystem));
}

static const AtomicString& applicationOctetStream()

MediaPlayer::MediaPlayer(MediaPlayerClient& client)
    : m_client(client)
    , m_reloadTimer(this, &MediaPlayer::reloadTimerFired)
    , m_private(std::make_unique<NullMediaPlayerPrivate>(this))
    , m_currentMediaEngine(0)
    , m_preload(Auto)
    , m_visible(false)

        m_private = nullptr;
    } else if (m_currentMediaEngine != engine) {
        m_currentMediaEngine = engine;
        m_private = engine->createMediaPlayer(this);
        m_client.mediaPlayerEngineUpdated(this);
        m_private->setPrivateBrowsingMode(m_privateBrowsing);
        m_private->setPreload(m_preload);

#endif
        m_private->load(m_url.string());
    } else {
        m_private = std::make_unique<NullMediaPlayerPrivate>(this);
        m_client.mediaPlayerEngineUpdated(this);
        m_client.mediaPlayerResourceNotSupported(this);
    }



#include "IntRect.h"
#include "URL.h"
#include "LayoutRect.h"
#include "MediaEnginePlayerType.h"
#include "MediaSession.h"
#include "NativeImagePtr.h"
#include "PlatformLayer.h"

#include <wtf/HashSet.h>
#include <wtf/MediaTime.h>
#include <wtf/Noncopyable.h>
#include <wtf/OwnPtr.h>
#include <wtf/PassOwnPtr.h>
#include <wtf/text/StringHash.h>

#if ENABLE(AVF_CAPTIONS)

class MediaPlayer {
    WTF_MAKE_NONCOPYABLE(MediaPlayer); WTF_MAKE_FAST_ALLOCATED;
public:
    explicit MediaPlayer(MediaPlayerClient&);
    static PassOwnPtr<MediaPlayer> create(MediaPlayerClient& client)
    {
        return adoptPtr(new MediaPlayer(client));
    }
    virtual ~MediaPlayer();

    // Media engine support.

    String sourceApplicationIdentifier() const;

private:
    MediaPlayer(MediaPlayerClient&);
    MediaPlayerFactory* nextBestMediaEngine(MediaPlayerFactory*) const;
    void loadWithNextMediaEngine(MediaPlayerFactory*);
    void reloadTimerFired(Timer<MediaPlayer>&);


    MediaPlayerClient& m_client;
    Timer<MediaPlayer> m_reloadTimer;
    std::unique_ptr<MediaPlayerPrivateInterface> m_private;
    MediaPlayerFactory* m_currentMediaEngine;
    URL m_url;
    String m_contentMIMEType;

#endif
};

typedef PassOwnPtr<MediaPlayerPrivateInterface> (*CreateMediaEnginePlayer)(MediaPlayer*);
typedef void (*MediaEngineSupportedTypes)(HashSet<String>& types);
typedef MediaPlayer::SupportsType (*MediaEngineSupportsType)(const MediaEngineSupportParameters& parameters);
typedef void (*MediaEngineGetSitesInMediaCache)(Vector<String>&);

typedef void (*MediaEngineClearMediaCacheForSite)(const String&);
typedef bool (*MediaEngineSupportsKeySystem)(const String& keySystem, const String& mimeType);

typedef void (*MediaEngineRegistrar)(MediaEnginePlayerType, MediaEngineSupportedTypes, MediaEngineSupportsType,
    MediaEngineGetSitesInMediaCache, MediaEngineClearMediaCache, MediaEngineClearMediaCacheForSite, MediaEngineSupportsKeySystem);
typedef void (*MediaEngineRegister)(MediaEngineRegistrar);




class MediaPlayerPrivateAVFoundation : public MediaPlayerPrivateInterface, public AVFInbandTrackParent
{
public:
    explicit MediaPlayerPrivateAVFoundation(MediaPlayer*);

    virtual void repaint();
    virtual void metadataLoaded();

#endif

protected:
    MediaPlayerPrivateAVFoundation(MediaPlayer*);
    virtual ~MediaPlayerPrivateAVFoundation();

    WeakPtr<MediaPlayerPrivateAVFoundation> createWeakPtr() { return m_weakPtrFactory.createWeakPtr(); }



}
#endif

PassOwnPtr<MediaPlayerPrivateInterface> MediaPlayerPrivateAVFoundationCF::create(MediaPlayer* player) 
{ 
    return adoptPtr(new MediaPlayerPrivateAVFoundationCF(player));
}

void MediaPlayerPrivateAVFoundationCF::registerMediaEngine(MediaEngineRegistrar registrar)
{
    if (isAvailable())
        registrar(AVFoundationCFPlayer, getSupportedTypes, supportsType, 0, 0, 0, supportsKeySystem);
}

MediaPlayerPrivateAVFoundationCF::MediaPlayerPrivateAVFoundationCF(MediaPlayer* player)




class MediaPlayerPrivateAVFoundationCF : public MediaPlayerPrivateAVFoundation {
public:
    explicit MediaPlayerPrivateAVFoundationCF(MediaPlayer*);
    virtual ~MediaPlayerPrivateAVFoundationCF();

    virtual void tracksChanged() override;

    static void registerMediaEngine(MediaEngineRegistrar);

private:
    MediaPlayerPrivateAVFoundationCF(MediaPlayer*);

    // Engine support
    static PassOwnPtr<MediaPlayerPrivateInterface> create(MediaPlayer*);
    static void getSupportedTypes(HashSet<String>& types);
    static MediaPlayer::SupportsType supportsType(const MediaEngineSupportParameters&);
    static bool supportsKeySystem(const String& keySystem, const String& mimeType);




class MediaPlayerPrivateAVFoundationObjC : public MediaPlayerPrivateAVFoundation {
public:
    explicit MediaPlayerPrivateAVFoundationObjC(MediaPlayer*);
    virtual ~MediaPlayerPrivateAVFoundationObjC();

    static void registerMediaEngine(MediaEngineRegistrar);

    WeakPtr<MediaPlayerPrivateAVFoundationObjC> createWeakPtr() { return m_weakPtrFactory.createWeakPtr(); }

private:
    MediaPlayerPrivateAVFoundationObjC(MediaPlayer*);

    // engine support
    static PassOwnPtr<MediaPlayerPrivateInterface> create(MediaPlayer*);
    static void getSupportedTypes(HashSet<String>& types);
    static MediaPlayer::SupportsType supportsType(const MediaEngineSupportParameters&);
    static bool supportsKeySystem(const String& keySystem, const String& mimeType);



}
#endif

PassOwnPtr<MediaPlayerPrivateInterface> MediaPlayerPrivateAVFoundationObjC::create(MediaPlayer* player)
{ 
    return adoptPtr(new MediaPlayerPrivateAVFoundationObjC(player));
}

void MediaPlayerPrivateAVFoundationObjC::registerMediaEngine(MediaEngineRegistrar registrar)
{
    if (isAvailable())
        registrar(AVFoundationObjCPlayer, getSupportedTypes, supportsType, 0, 0, 0, supportsKeySystem);
}

MediaPlayerPrivateAVFoundationObjC::MediaPlayerPrivateAVFoundationObjC(MediaPlayer* player)




class MediaPlayerPrivateMediaSourceAVFObjC : public MediaPlayerPrivateInterface {
public:
    explicit MediaPlayerPrivateMediaSourceAVFObjC(MediaPlayer*);
    virtual ~MediaPlayerPrivateMediaSourceAVFObjC();

    static void registerMediaEngine(MediaEngineRegistrar);

    // MediaPlayer Factory Methods
    static PassOwnPtr<MediaPlayerPrivateInterface> create(MediaPlayer*);
    static bool isAvailable();
    static void getSupportedTypes(HashSet<String>& types);
    static MediaPlayer::SupportsType supportsType(const MediaEngineSupportParameters&);



void MediaPlayerPrivateMediaSourceAVFObjC::registerMediaEngine(MediaEngineRegistrar registrar)
{
    if (isAvailable())
        registrar(MediaSourceAVFObjCPlayer, getSupportedTypes, supportsType, 0, 0, 0, 0);
}

PassOwnPtr<MediaPlayerPrivateInterface> MediaPlayerPrivateMediaSourceAVFObjC::create(MediaPlayer* player)
{
    return adoptPtr(new MediaPlayerPrivateMediaSourceAVFObjC(player));
}

bool MediaPlayerPrivateMediaSourceAVFObjC::isAvailable()



    LOG_MEDIA_MESSAGE("Set media.role as %s at %s", role, elementName.get());
}

PassOwnPtr<MediaPlayerPrivateInterface> MediaPlayerPrivateGStreamer::create(MediaPlayer* player)
{
    return adoptPtr(new MediaPlayerPrivateGStreamer(player));
}

void MediaPlayerPrivateGStreamer::registerMediaEngine(MediaEngineRegistrar registrar)
{
    if (isAvailable())
        registrar(GStreamerPlayer, getSupportedTypes, supportsType, 0, 0, 0, 0);
}

bool initializeGStreamerAndRegisterWebKitElements()




class MediaPlayerPrivateGStreamer : public MediaPlayerPrivateGStreamerBase {
public:
    explicit MediaPlayerPrivateGStreamer(MediaPlayer*);
    ~MediaPlayerPrivateGStreamer();

    static void registerMediaEngine(MediaEngineRegistrar);
    gboolean handleMessage(GstMessage*);
    void handlePluginInstallerResult(GstInstallPluginsReturn);

    bool changePipelineState(GstState);

private:
    MediaPlayerPrivateGStreamer(MediaPlayer*);

    static PassOwnPtr<MediaPlayerPrivateInterface> create(MediaPlayer*);

    static void getSupportedTypes(HashSet<String>&);
    static MediaPlayer::SupportsType supportsType(const MediaEngineSupportParameters&);




    
class MediaPlayerPrivateQTKit : public MediaPlayerPrivateInterface {
public:
    explicit MediaPlayerPrivateQTKit(MediaPlayer*);
    ~MediaPlayerPrivateQTKit();
    WEBCORE_EXPORT static void registerMediaEngine(MediaEngineRegistrar);


    void layerHostChanged(PlatformLayer* rootLayer);

private:
    MediaPlayerPrivateQTKit(MediaPlayer*);

    // engine support
    static PassOwnPtr<MediaPlayerPrivateInterface> create(MediaPlayer*);
    static void getSupportedTypes(HashSet<String>& types);
    static MediaPlayer::SupportsType supportsType(const MediaEngineSupportParameters&);





namespace WebCore {

PassOwnPtr<MediaPlayerPrivateInterface> MediaPlayerPrivateQTKit::create(MediaPlayer* player)
{ 
    return adoptPtr(new MediaPlayerPrivateQTKit(player));
}

void MediaPlayerPrivateQTKit::registerMediaEngine(MediaEngineRegistrar registrar)
{
    if (isAvailable())
        registrar(QTKitPlayer, getSupportedTypes, supportsType, getSitesInMediaCache, clearMediaCache, clearMediaCacheForSite, 0);
}

MediaPlayerPrivateQTKit::MediaPlayerPrivateQTKit(MediaPlayer* player)



{
}

PassOwnPtr<MediaPlayerPrivateInterface> MediaPlayerPrivateMediaFoundation::create(MediaPlayer* player)
{
    return adoptPtr(new MediaPlayerPrivateMediaFoundation(player));
}

void MediaPlayerPrivateMediaFoundation::registerMediaEngine(MediaEngineRegistrar registrar)
{
    if (isAvailable())
        registrar(MediaFoundationPlayer, getSupportedTypes, supportsType, 0, 0, 0, 0);
}

bool MediaPlayerPrivateMediaFoundation::isAvailable() 




class MediaPlayerPrivateMediaFoundation : public MediaPlayerPrivateInterface {
public:
    explicit MediaPlayerPrivateMediaFoundation(MediaPlayer*);
    static void registerMediaEngine(MediaEngineRegistrar);

    static PassOwnPtr<MediaPlayerPrivateInterface> create(MediaPlayer*);
    static void getSupportedTypes(HashSet<String>& types);
    static MediaPlayer::SupportsType supportsType(const MediaEngineSupportParameters&);
    static bool isAvailable();



// MediaPlayer Enigne Support
void MockMediaPlayerMediaSource::registerMediaEngine(MediaEngineRegistrar registrar)
{
    registrar(MockMediaSourcePlayer, getSupportedTypes, supportsType, 0, 0, 0, 0);
}

PassOwnPtr<MediaPlayerPrivateInterface> MockMediaPlayerMediaSource::create(MediaPlayer* player)
{
    return adoptPtr(new MockMediaPlayerMediaSource(player));
}

static HashSet<String> mimeTypeCache()

Lines 38-46 class MockMediaSourcePrivate; a/Source/WebCore/platform/mock/mediasource/MockMediaPlayerMediaSource.h_sec1
- a/Source/WebCore/platform/mock/mediasource/MockMediaPlayerMediaSource.h -3 / +2 lines
38		38
39	class MockMediaPlayerMediaSource : public MediaPlayerPrivateInterface {	39	class MockMediaPlayerMediaSource : public MediaPlayerPrivateInterface {
40	public:	40	public:
		41	explicit MockMediaPlayerMediaSource(MediaPlayer*);
		42
41	// MediaPlayer Engine Support	43	// MediaPlayer Engine Support
42	static void registerMediaEngine(MediaEngineRegistrar);	44	static void registerMediaEngine(MediaEngineRegistrar);
43	static PassOwnPtr<MediaPlayerPrivateInterface> create(MediaPlayer*);
44	static void getSupportedTypes(HashSet<String>& types);	45	static void getSupportedTypes(HashSet<String>& types);
45	static MediaPlayer::SupportsType supportsType(const MediaEngineSupportParameters&);	46	static MediaPlayer::SupportsType supportsType(const MediaEngineSupportParameters&);
46		47
Lines 56-63 public: a/Source/WebCore/platform/mock/mediasource/MockMediaPlayerMediaSource.h_sec2
56	void seekCompleted();	57	void seekCompleted();
57		58
58	private:	59	private:
59	MockMediaPlayerMediaSource(MediaPlayer*);
60
61	// MediaPlayerPrivate Overrides	60	// MediaPlayerPrivate Overrides
62	virtual void load(const String& url) override;	61	virtual void load(const String& url) override;
63	virtual void load(const String& url, MediaSourcePrivateClient*) override;	62	virtual void load(const String& url, MediaSourcePrivateClient*) override;

Return to Bug 137765

Lines 4646-4652 void HTMLMediaElement::clearMediaPlayer(int flags) a/Source/WebCore/html/HTMLMediaElement.cpp_sec1
- a/Source/WebCore/html/HTMLMediaElement.cpp -3 / +3 lines
4646	m_mediaSession->setHasPlaybackTargetAvailabilityListeners(*this, false);	4646	m_mediaSession->setHasPlaybackTargetAvailabilityListeners(*this, false);
4647	#endif	4647	#endif
4648		4648
4649	m_player.clear();	4649	m_player = nullptr;
4650		4650
4651	stopPeriodicTimers();	4651	stopPeriodicTimers();
4652	m_loadTimer.stop();	4652	m_loadTimer.stop();
Lines 4693-4699 void HTMLMediaElement::stop() a/Source/WebCore/html/HTMLMediaElement.cpp_sec2
4693	// Once an active DOM object has been stopped it can not be restarted, so we can deallocate	4693	// Once an active DOM object has been stopped it can not be restarted, so we can deallocate
4694	// the media player now. Note that userCancelledLoad will already have cleared the player	4694	// the media player now. Note that userCancelledLoad will already have cleared the player
4695	// if the media was not fully loaded. This handles all other cases.	4695	// if the media was not fully loaded. This handles all other cases.
4696	m_player.clear();	4696	m_player = nullptr;
4697		4697
4698	updateSleepDisabling();	4698	updateSleepDisabling();
4699	}	4699	}
Lines 5334-5340 void HTMLMediaElement::createMediaPlayer() a/Source/WebCore/html/HTMLMediaElement.cpp_sec3
5334	#if ENABLE(VIDEO_TRACK)	5334	#if ENABLE(VIDEO_TRACK)
5335	forgetResourceSpecificTracks();	5335	forgetResourceSpecificTracks();
5336	#endif	5336	#endif
5337	m_player = MediaPlayer::create(*this);	5337	m_player = std::make_unique<MediaPlayer>(static_cast<MediaPlayerClient&>(*this));
5338		5338
5339	#if ENABLE(WEB_AUDIO)	5339	#if ENABLE(WEB_AUDIO)
5340	if (m_audioSourceNode) {	5340	if (m_audioSourceNode) {

Lines 78-84 const PlatformMedia NoPlatformMedia = { PlatformMedia::None, {0} }; a/Source/WebCore/platform/graphics/MediaPlayer.cpp_sec1
- a/Source/WebCore/platform/graphics/MediaPlayer.cpp -22 / +56 lines
78		78
79	class NullMediaPlayerPrivate : public MediaPlayerPrivateInterface {	79	class NullMediaPlayerPrivate : public MediaPlayerPrivateInterface {
80	public:	80	public:
81	NullMediaPlayerPrivate(MediaPlayer*) { }	81	explicit NullMediaPlayerPrivate(MediaPlayer*) { }
82		82
83	virtual void load(const String&) { }	83	virtual void load(const String&) { }
84	#if ENABLE(MEDIA_SOURCE)	84	#if ENABLE(MEDIA_SOURCE)
Lines 144-182 public: a/Source/WebCore/platform/graphics/MediaPlayer.cpp_sec2
144	#endif	144	#endif
145	};	145	};
146		146
147	static PassOwnPtr<MediaPlayerPrivateInterface> createNullMediaPlayer(MediaPlayer* player)
148	{
149	return adoptPtr(new NullMediaPlayerPrivate(player));
150	}
151
152		147
153	// engine support	148	// engine support
154		149
155	struct MediaPlayerFactory {	150	struct MediaPlayerFactory {
156	WTF_MAKE_NONCOPYABLE(MediaPlayerFactory); WTF_MAKE_FAST_ALLOCATED;	151	WTF_MAKE_NONCOPYABLE(MediaPlayerFactory); WTF_MAKE_FAST_ALLOCATED;
157	public:	152	public:
158	MediaPlayerFactory(CreateMediaEnginePlayer constructor, MediaEngineSupportedTypes getSupportedTypes, MediaEngineSupportsType supportsTypeAndCodecs,	153	MediaPlayerFactory(MediaEnginePlayerType playerType, MediaEngineSupportedTypes getSupportedTypes, MediaEngineSupportsType supportsTypeAndCodecs,
159	MediaEngineGetSitesInMediaCache getSitesInMediaCache, MediaEngineClearMediaCache clearMediaCache, MediaEngineClearMediaCacheForSite clearMediaCacheForSite, MediaEngineSupportsKeySystem supportsKeySystem)	154	MediaEngineGetSitesInMediaCache getSitesInMediaCache, MediaEngineClearMediaCache clearMediaCache, MediaEngineClearMediaCacheForSite clearMediaCacheForSite, MediaEngineSupportsKeySystem supportsKeySystem)
160	: constructor(constructor)	155	: playerType(playerType)
161	, getSupportedTypes(getSupportedTypes)	156	, getSupportedTypes(getSupportedTypes)
162	, supportsTypeAndCodecs(supportsTypeAndCodecs)	157	, supportsTypeAndCodecs(supportsTypeAndCodecs)
163	, getSitesInMediaCache(getSitesInMediaCache)	158	, getSitesInMediaCache(getSitesInMediaCache)
164	, clearMediaCache(clearMediaCache)	159	, clearMediaCache(clearMediaCache)
165	, clearMediaCacheForSite(clearMediaCacheForSite)	160	, clearMediaCacheForSite(clearMediaCacheForSite)
166	, supportsKeySystem(supportsKeySystem)	161	, supportsKeySystem(supportsKeySystem)
167	{	162	{
168	}	163	}
169		164
170	CreateMediaEnginePlayer constructor;	165	MediaEnginePlayerType playerType;
171	MediaEngineSupportedTypes getSupportedTypes;	166	MediaEngineSupportedTypes getSupportedTypes;
172	MediaEngineSupportsType supportsTypeAndCodecs;	167	MediaEngineSupportsType supportsTypeAndCodecs;
173	MediaEngineGetSitesInMediaCache getSitesInMediaCache;	168	MediaEngineGetSitesInMediaCache getSitesInMediaCache;
174	MediaEngineClearMediaCache clearMediaCache;	169	MediaEngineClearMediaCache clearMediaCache;
175	MediaEngineClearMediaCacheForSite clearMediaCacheForSite;	170	MediaEngineClearMediaCacheForSite clearMediaCacheForSite;
176	MediaEngineSupportsKeySystem supportsKeySystem;	171	MediaEngineSupportsKeySystem supportsKeySystem;
		172
		173	std::unique_ptr<MediaPlayerPrivateInterface> createMediaPlayer(MediaPlayer* player)
		174	{
		175	switch (playerType) {
		176	case NullMediaPlayer:
		177	return std::make_unique<NullMediaPlayerPrivate>(player);
		178	#if PLATFORM(WIN) && ENABLE(VIDEO) && USE(AVFOUNDATION)
		179	case AVFoundationCFPlayer:
		180	return std::make_unique<MediaPlayerPrivateAVFoundationCF>(player);
		181	#endif
		182	#if ENABLE(VIDEO) && USE(AVFOUNDATION)
		183	case AVFoundationObjCPlayer:
		184	return std::make_unique<MediaPlayerPrivateAVFoundationObjC>(player);
		185	#endif
		186	#if ENABLE(MEDIA_SOURCE) && USE(AVFOUNDATION)
		187	case MediaSourceAVFObjCPlayer:
		188	return std::make_unique<MediaPlayerPrivateMediaSourceAVFObjC>(player);
		189	#endif
		190	#if ENABLE(VIDEO) && USE(GSTREAMER)
		191	case GStreamerPlayer:
		192	return std::make_unique<MediaPlayerPrivateGStreamer>(player);
		193	#endif
		194	#if ENABLE(VIDEO) && PLATFORM(MAC)
		195	case QTKitPlayer:
		196	return std::make_unique<MediaPlayerPrivateQTKit>(player);
		197	#endif
		198	#if USE(MEDIA_FOUNDATION)
		199	case MediaFoundationPlayer:
		200	return std::make_unique<MediaPlayerPrivateMediaFoundation>(player);
		201	#endif
		202	#if ENABLE(MEDIA_SOURCE)
		203	case MockMediaSourcePlayer:
		204	return std::make_unique<MockMediaPlayerMediaSource>(player);
		205	#endif
		206	default:
		207	ASSERT_NOT_REACHED();
		208	return std::make_unique<NullMediaPlayerPrivate>(player);
		209	}
		210	}
177	};	211	};
178		212
179	static void addMediaEngine(CreateMediaEnginePlayer, MediaEngineSupportedTypes, MediaEngineSupportsType, MediaEngineGetSitesInMediaCache, MediaEngineClearMediaCache, MediaEngineClearMediaCacheForSite, MediaEngineSupportsKeySystem);	213	static void addMediaEngine(MediaEnginePlayerType, MediaEngineSupportedTypes, MediaEngineSupportsType, MediaEngineGetSitesInMediaCache, MediaEngineClearMediaCache, MediaEngineClearMediaCacheForSite, MediaEngineSupportsKeySystem);
180		214
181	static MediaPlayerFactory* bestMediaEngineForSupportParameters(const MediaEngineSupportParameters&, MediaPlayerFactory* current = 0);	215	static MediaPlayerFactory* bestMediaEngineForSupportParameters(const MediaEngineSupportParameters&, MediaPlayerFactory* current = 0);
182	static MediaPlayerFactory* nextMediaEngine(MediaPlayerFactory* current);	216	static MediaPlayerFactory* nextMediaEngine(MediaPlayerFactory* current);
Lines 223-236 static Vector<MediaPlayerFactory*>& installedMediaEngines(RequeryEngineOptions r a/Source/WebCore/platform/graphics/MediaPlayer.cpp_sec3
223	return installedEngines;	257	return installedEngines;
224	}	258	}
225		259
226	static void addMediaEngine(CreateMediaEnginePlayer constructor, MediaEngineSupportedTypes getSupportedTypes, MediaEngineSupportsType supportsType,	260	static void addMediaEngine(MediaEnginePlayerType playerType, MediaEngineSupportedTypes getSupportedTypes, MediaEngineSupportsType supportsType,
227	MediaEngineGetSitesInMediaCache getSitesInMediaCache, MediaEngineClearMediaCache clearMediaCache, MediaEngineClearMediaCacheForSite clearMediaCacheForSite, MediaEngineSupportsKeySystem supportsKeySystem)	261	MediaEngineGetSitesInMediaCache getSitesInMediaCache, MediaEngineClearMediaCache clearMediaCache, MediaEngineClearMediaCacheForSite clearMediaCacheForSite, MediaEngineSupportsKeySystem supportsKeySystem)
228	{	262	{
229	ASSERT(constructor);	263	ASSERT(playerType);
230	ASSERT(getSupportedTypes);	264	ASSERT(getSupportedTypes);
231	ASSERT(supportsType);	265	ASSERT(supportsType);
232		266
233	installedMediaEngines().append(new MediaPlayerFactory(constructor, getSupportedTypes, supportsType, getSitesInMediaCache, clearMediaCache, clearMediaCacheForSite, supportsKeySystem));	267	installedMediaEngines().append(new MediaPlayerFactory(playerType, getSupportedTypes, supportsType, getSitesInMediaCache, clearMediaCache, clearMediaCacheForSite, supportsKeySystem));
234	}	268	}
235		269
236	static const AtomicString& applicationOctetStream()	270	static const AtomicString& applicationOctetStream()
Lines 308-314 static MediaPlayerFactory* nextMediaEngine(MediaPlayerFactory* current) a/Source/WebCore/platform/graphics/MediaPlayer.cpp_sec4
308	MediaPlayer::MediaPlayer(MediaPlayerClient& client)	342	MediaPlayer::MediaPlayer(MediaPlayerClient& client)
309	: m_client(client)	343	: m_client(client)
310	, m_reloadTimer(this, &MediaPlayer::reloadTimerFired)	344	, m_reloadTimer(this, &MediaPlayer::reloadTimerFired)
311	, m_private(createNullMediaPlayer(this))	345	, m_private(std::make_unique<NullMediaPlayerPrivate>(this))
312	, m_currentMediaEngine(0)	346	, m_currentMediaEngine(0)
313	, m_preload(Auto)	347	, m_preload(Auto)
314	, m_visible(false)	348	, m_visible(false)
Lines 409-415 void MediaPlayer::loadWithNextMediaEngine(MediaPlayerFactory* current) a/Source/WebCore/platform/graphics/MediaPlayer.cpp_sec5
409	m_private = nullptr;	443	m_private = nullptr;
410	} else if (m_currentMediaEngine != engine) {	444	} else if (m_currentMediaEngine != engine) {
411	m_currentMediaEngine = engine;	445	m_currentMediaEngine = engine;
412	m_private = engine->constructor(this);	446	m_private = engine->createMediaPlayer(this);
413	m_client.mediaPlayerEngineUpdated(this);	447	m_client.mediaPlayerEngineUpdated(this);
414	m_private->setPrivateBrowsingMode(m_privateBrowsing);	448	m_private->setPrivateBrowsingMode(m_privateBrowsing);
415	m_private->setPreload(m_preload);	449	m_private->setPreload(m_preload);
Lines 426-432 void MediaPlayer::loadWithNextMediaEngine(MediaPlayerFactory* current) a/Source/WebCore/platform/graphics/MediaPlayer.cpp_sec6
426	#endif	460	#endif
427	m_private->load(m_url.string());	461	m_private->load(m_url.string());
428	} else {	462	} else {
429	m_private = createNullMediaPlayer(this);	463	m_private = std::make_unique<NullMediaPlayerPrivate>(this);
430	m_client.mediaPlayerEngineUpdated(this);	464	m_client.mediaPlayerEngineUpdated(this);
431	m_client.mediaPlayerResourceNotSupported(this);	465	m_client.mediaPlayerResourceNotSupported(this);
432	}	466	}

Lines 35-40 a/Source/WebCore/platform/graphics/MediaPlayer.h_sec1
- a/Source/WebCore/platform/graphics/MediaPlayer.h -11 / +4 lines
35	#include "IntRect.h"	35	#include "IntRect.h"
36	#include "URL.h"	36	#include "URL.h"
37	#include "LayoutRect.h"	37	#include "LayoutRect.h"
		38	#include "MediaEnginePlayerType.h"
38	#include "MediaSession.h"	39	#include "MediaSession.h"
39	#include "NativeImagePtr.h"	40	#include "NativeImagePtr.h"
40	#include "PlatformLayer.h"	41	#include "PlatformLayer.h"
Lines 45-52 a/Source/WebCore/platform/graphics/MediaPlayer.h_sec2
45	#include <wtf/HashSet.h>	46	#include <wtf/HashSet.h>
46	#include <wtf/MediaTime.h>	47	#include <wtf/MediaTime.h>
47	#include <wtf/Noncopyable.h>	48	#include <wtf/Noncopyable.h>
48	#include <wtf/OwnPtr.h>
49	#include <wtf/PassOwnPtr.h>
50	#include <wtf/text/StringHash.h>	49	#include <wtf/text/StringHash.h>
51		50
52	#if ENABLE(AVF_CAPTIONS)	51	#if ENABLE(AVF_CAPTIONS)
Lines 278-288 public: a/Source/WebCore/platform/graphics/MediaPlayer.h_sec3
278	class MediaPlayer {	277	class MediaPlayer {
279	WTF_MAKE_NONCOPYABLE(MediaPlayer); WTF_MAKE_FAST_ALLOCATED;	278	WTF_MAKE_NONCOPYABLE(MediaPlayer); WTF_MAKE_FAST_ALLOCATED;
280	public:	279	public:
281		280	explicit MediaPlayer(MediaPlayerClient&);
282	static PassOwnPtr<MediaPlayer> create(MediaPlayerClient& client)
283	{
284	return adoptPtr(new MediaPlayer(client));
285	}
286	virtual ~MediaPlayer();	281	virtual ~MediaPlayer();
287		282
288	// Media engine support.	283	// Media engine support.
Lines 577-583 public: a/Source/WebCore/platform/graphics/MediaPlayer.h_sec4
577	String sourceApplicationIdentifier() const;	572	String sourceApplicationIdentifier() const;
578		573
579	private:	574	private:
580	MediaPlayer(MediaPlayerClient&);
581	MediaPlayerFactory* nextBestMediaEngine(MediaPlayerFactory*) const;	575	MediaPlayerFactory* nextBestMediaEngine(MediaPlayerFactory*) const;
582	void loadWithNextMediaEngine(MediaPlayerFactory*);	576	void loadWithNextMediaEngine(MediaPlayerFactory*);
583	void reloadTimerFired(Timer<MediaPlayer>&);	577	void reloadTimerFired(Timer<MediaPlayer>&);
Lines 586-592 private: a/Source/WebCore/platform/graphics/MediaPlayer.h_sec5
586		580
587	MediaPlayerClient& m_client;	581	MediaPlayerClient& m_client;
588	Timer<MediaPlayer> m_reloadTimer;	582	Timer<MediaPlayer> m_reloadTimer;
589	OwnPtr<MediaPlayerPrivateInterface> m_private;	583	std::unique_ptr<MediaPlayerPrivateInterface> m_private;
590	MediaPlayerFactory* m_currentMediaEngine;	584	MediaPlayerFactory* m_currentMediaEngine;
591	URL m_url;	585	URL m_url;
592	String m_contentMIMEType;	586	String m_contentMIMEType;
Lines 608-614 private: a/Source/WebCore/platform/graphics/MediaPlayer.h_sec6
608	#endif	602	#endif
609	};	603	};
610		604
611	typedef PassOwnPtr<MediaPlayerPrivateInterface> (CreateMediaEnginePlayer)(MediaPlayer);
612	typedef void (*MediaEngineSupportedTypes)(HashSet<String>& types);	605	typedef void (*MediaEngineSupportedTypes)(HashSet<String>& types);
613	typedef MediaPlayer::SupportsType (*MediaEngineSupportsType)(const MediaEngineSupportParameters& parameters);	606	typedef MediaPlayer::SupportsType (*MediaEngineSupportsType)(const MediaEngineSupportParameters& parameters);
614	typedef void (*MediaEngineGetSitesInMediaCache)(Vector<String>&);	607	typedef void (*MediaEngineGetSitesInMediaCache)(Vector<String>&);
Lines 616-622 typedef void (*MediaEngineClearMediaCache)(); a/Source/WebCore/platform/graphics/MediaPlayer.h_sec7
616	typedef void (*MediaEngineClearMediaCacheForSite)(const String&);	609	typedef void (*MediaEngineClearMediaCacheForSite)(const String&);
617	typedef bool (*MediaEngineSupportsKeySystem)(const String& keySystem, const String& mimeType);	610	typedef bool (*MediaEngineSupportsKeySystem)(const String& keySystem, const String& mimeType);
618		611
619	typedef void (*MediaEngineRegistrar)(CreateMediaEnginePlayer, MediaEngineSupportedTypes, MediaEngineSupportsType,	612	typedef void (*MediaEngineRegistrar)(MediaEnginePlayerType, MediaEngineSupportedTypes, MediaEngineSupportsType,
620	MediaEngineGetSitesInMediaCache, MediaEngineClearMediaCache, MediaEngineClearMediaCacheForSite, MediaEngineSupportsKeySystem);	613	MediaEngineGetSitesInMediaCache, MediaEngineClearMediaCache, MediaEngineClearMediaCacheForSite, MediaEngineSupportsKeySystem);
621	typedef void (*MediaEngineRegister)(MediaEngineRegistrar);	614	typedef void (*MediaEngineRegister)(MediaEngineRegistrar);
622		615

Lines 46-51 class GenericCueData; a/Source/WebCore/platform/graphics/avfoundation/MediaPlayerPrivateAVFoundation.h_sec1
- a/Source/WebCore/platform/graphics/avfoundation/MediaPlayerPrivateAVFoundation.h -1 / +1 lines
46	class MediaPlayerPrivateAVFoundation : public MediaPlayerPrivateInterface, public AVFInbandTrackParent	46	class MediaPlayerPrivateAVFoundation : public MediaPlayerPrivateInterface, public AVFInbandTrackParent
47	{	47	{
48	public:	48	public:
		49	explicit MediaPlayerPrivateAVFoundation(MediaPlayer*);
49		50
50	virtual void repaint();	51	virtual void repaint();
51	virtual void metadataLoaded();	52	virtual void metadataLoaded();
Lines 144-150 public: a/Source/WebCore/platform/graphics/avfoundation/MediaPlayerPrivateAVFoundation.h_sec2
144	#endif	145	#endif
145		146
146	protected:	147	protected:
147	MediaPlayerPrivateAVFoundation(MediaPlayer*);
148	virtual ~MediaPlayerPrivateAVFoundation();	148	virtual ~MediaPlayerPrivateAVFoundation();
149		149
150	WeakPtr<MediaPlayerPrivateAVFoundation> createWeakPtr() { return m_weakPtrFactory.createWeakPtr(); }	150	WeakPtr<MediaPlayerPrivateAVFoundation> createWeakPtr() { return m_weakPtrFactory.createWeakPtr(); }

Lines 335-349 static dispatch_queue_t globalLoaderDelegateQueue() a/Source/WebCore/platform/graphics/avfoundation/cf/MediaPlayerPrivateAVFoundationCF.cpp_sec1
- a/Source/WebCore/platform/graphics/avfoundation/cf/MediaPlayerPrivateAVFoundationCF.cpp -6 / +1 lines
335	}	335	}
336	#endif	336	#endif
337		337
338	PassOwnPtr<MediaPlayerPrivateInterface> MediaPlayerPrivateAVFoundationCF::create(MediaPlayer* player)
339	{
340	return adoptPtr(new MediaPlayerPrivateAVFoundationCF(player));
341	}
342
343	void MediaPlayerPrivateAVFoundationCF::registerMediaEngine(MediaEngineRegistrar registrar)	338	void MediaPlayerPrivateAVFoundationCF::registerMediaEngine(MediaEngineRegistrar registrar)
344	{	339	{
345	if (isAvailable())	340	if (isAvailable())
346	registrar(create, getSupportedTypes, supportsType, 0, 0, 0, supportsKeySystem);	341	registrar(AVFoundationCFPlayer, getSupportedTypes, supportsType, 0, 0, 0, supportsKeySystem);
347	}	342	}
348		343
349	MediaPlayerPrivateAVFoundationCF::MediaPlayerPrivateAVFoundationCF(MediaPlayer* player)	344	MediaPlayerPrivateAVFoundationCF::MediaPlayerPrivateAVFoundationCF(MediaPlayer* player)

Lines 1-3 a/Source/WebCore/ChangeLog_sec1
- a/Source/WebCore/ChangeLog +60 lines
		1	2014-10-20 Gyuyoung Kim <gyuyoung.kim@samsung.com>
		2
		3	Use std::unique_ptr instead of PassOwnPtr in MediaPlayerFoo classes
		4	https://bugs.webkit.org/show_bug.cgi?id=137765
		5
		6	Reviewed by NOBODY (OOPS!).
		7
		8	As a step to use std::unique_ptr\|make_unique<>, this patch changes use of OwnPtr\|PassOwnPtr with
		9	std::unique_ptr<>\|make_unique<>. However we have to set constructor to public in order to use
		10	std::make_unique<>. This change will conflict with MediaPlayerFoo's create() factory function
		11	because there are two object creation methods. Thus this patch removes create() factory function
		12	in MediaPlayerFoo classes and also lets MediaPlayerFactory create MediaPlayerFoo using std::make_unique<>
		13	instead of the create() factory functions.
		14
		15	No new tests, no behavior changes.
		16
		17	* html/HTMLMediaElement.cpp:
		18	(WebCore::HTMLMediaElement::parseAttribute):
		19	* html/HTMLMediaElement.h:
		20	* platform/graphics/MediaEnginePlayerType.h: Added.
		21	* platform/graphics/MediaPlayer.cpp:
		22	(WebCore::NullMediaPlayerPrivate::NullMediaPlayerPrivate):
		23	(WebCore::MediaPlayerFactory::MediaPlayerFactory):
		24	(WebCore::MediaPlayerFactory::createMediaPlayer):
		25	(WebCore::addMediaEngine):
		26	(WebCore::MediaPlayer::MediaPlayer):
		27	(WebCore::MediaPlayer::loadWithNextMediaEngine):
		28	(WebCore::createNullMediaPlayer): Deleted.
		29	* platform/graphics/MediaPlayer.h:
		30	(WebCore::MediaPlayer::create): Deleted.
		31	* platform/graphics/avfoundation/MediaPlayerPrivateAVFoundation.h:
		32	* platform/graphics/avfoundation/cf/MediaPlayerPrivateAVFoundationCF.cpp:
		33	(WebCore::MediaPlayerPrivateAVFoundationCF::registerMediaEngine):
		34	(WebCore::MediaPlayerPrivateAVFoundationCF::create): Deleted.
		35	* platform/graphics/avfoundation/cf/MediaPlayerPrivateAVFoundationCF.h:
		36	* platform/graphics/avfoundation/objc/MediaPlayerPrivateAVFoundationObjC.h:
		37	* platform/graphics/avfoundation/objc/MediaPlayerPrivateAVFoundationObjC.mm:
		38	(WebCore::MediaPlayerPrivateAVFoundationObjC::registerMediaEngine):
		39	(WebCore::MediaPlayerPrivateAVFoundationObjC::create): Deleted.
		40	* platform/graphics/avfoundation/objc/MediaPlayerPrivateMediaSourceAVFObjC.h:
		41	* platform/graphics/avfoundation/objc/MediaPlayerPrivateMediaSourceAVFObjC.mm:
		42	(WebCore::MediaPlayerPrivateMediaSourceAVFObjC::registerMediaEngine):
		43	(WebCore::MediaPlayerPrivateMediaSourceAVFObjC::create): Deleted.
		44	* platform/graphics/gstreamer/MediaPlayerPrivateGStreamer.cpp:
		45	(WebCore::MediaPlayerPrivateGStreamer::registerMediaEngine):
		46	(WebCore::MediaPlayerPrivateGStreamer::create): Deleted.
		47	* platform/graphics/gstreamer/MediaPlayerPrivateGStreamer.h:
		48	* platform/graphics/mac/MediaPlayerPrivateQTKit.h:
		49	* platform/graphics/mac/MediaPlayerPrivateQTKit.mm:
		50	(WebCore::MediaPlayerPrivateQTKit::registerMediaEngine):
		51	(WebCore::MediaPlayerPrivateQTKit::create): Deleted.
		52	* platform/graphics/win/MediaPlayerPrivateMediaFoundation.cpp:
		53	(WebCore::MediaPlayerPrivateMediaFoundation::registerMediaEngine):
		54	(WebCore::MediaPlayerPrivateMediaFoundation::create): Deleted.
		55	* platform/graphics/win/MediaPlayerPrivateMediaFoundation.h:
		56	* platform/mock/mediasource/MockMediaPlayerMediaSource.cpp:
		57	(WebCore::MockMediaPlayerMediaSource::registerMediaEngine):
		58	(WebCore::MockMediaPlayerMediaSource::create): Deleted.
		59	* platform/mock/mediasource/MockMediaPlayerMediaSource.h:
		60
1	2014-10-19 Chris Dumez <cdumez@apple.com>	61	2014-10-19 Chris Dumez <cdumez@apple.com>
2		62
3	Use is<>() / downcast<>() for all remaining RenderObject subclasses	63	Use is<>() / downcast<>() for all remaining RenderObject subclasses

Line 0 a/Source/WebCore/platform/graphics/MediaEnginePlayerType.h_sec1
- a/Source/WebCore/platform/graphics/MediaEnginePlayerType.h +43 lines
	1	/*
	2	* Copyright (C) 2014 Samsung Electronics. All rights reserved.
	3	*
	4	* Redistribution and use in source and binary forms, with or without
	5	* modification, are permitted provided that the following conditions
	6	* are met:
	7	* 1. Redistributions of source code must retain the above copyright
	8	* notice, this list of conditions and the following disclaimer.
	9	* 2. Redistributions in binary form must reproduce the above copyright
	10	* notice, this list of conditions and the following disclaimer in the
	11	* documentation and/or other materials provided with the distribution.
	12	*
	13	* THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
	14	* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
	15	* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
	16	* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR
	17	* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
	18	* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
	19	* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
	20	* PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
	21	* OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
	22	* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
	23	* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
	24	*/
	25
	26
	27	#ifndef MediaEnginePlayerType_h
	28	#define MediaEnginePlayerType_h
	29
	30	namespace WebCore {
	31	typedef enum {
	32	NullMediaPlayer,
	33	AVFoundationCFPlayer,
	34	AVFoundationObjCPlayer,
	35	MediaSourceAVFObjCPlayer,
	36	GStreamerPlayer,
	37	QTKitPlayer,
	38	MediaFoundationPlayer,
	39	MockMediaSourcePlayer
	40	} MediaEnginePlayerType;
	41	}
	42
	43	#endif

Lines 41-46 class WebCoreAVCFResourceLoader; a/Source/WebCore/platform/graphics/avfoundation/cf/MediaPlayerPrivateAVFoundationCF.h_sec1
- a/Source/WebCore/platform/graphics/avfoundation/cf/MediaPlayerPrivateAVFoundationCF.h -3 / +1 lines
41		41
42	class MediaPlayerPrivateAVFoundationCF : public MediaPlayerPrivateAVFoundation {	42	class MediaPlayerPrivateAVFoundationCF : public MediaPlayerPrivateAVFoundation {
43	public:	43	public:
		44	explicit MediaPlayerPrivateAVFoundationCF(MediaPlayer*);
44	virtual ~MediaPlayerPrivateAVFoundationCF();	45	virtual ~MediaPlayerPrivateAVFoundationCF();
45		46
46	virtual void tracksChanged() override;	47	virtual void tracksChanged() override;
Lines 58-67 public: a/Source/WebCore/platform/graphics/avfoundation/cf/MediaPlayerPrivateAVFoundationCF.h_sec2
58	static void registerMediaEngine(MediaEngineRegistrar);	59	static void registerMediaEngine(MediaEngineRegistrar);
59		60
60	private:	61	private:
61	MediaPlayerPrivateAVFoundationCF(MediaPlayer*);
62
63	// Engine support	62	// Engine support
64	static PassOwnPtr<MediaPlayerPrivateInterface> create(MediaPlayer*);
65	static void getSupportedTypes(HashSet<String>& types);	63	static void getSupportedTypes(HashSet<String>& types);
66	static MediaPlayer::SupportsType supportsType(const MediaEngineSupportParameters&);	64	static MediaPlayer::SupportsType supportsType(const MediaEngineSupportParameters&);
67	static bool supportsKeySystem(const String& keySystem, const String& mimeType);	65	static bool supportsKeySystem(const String& keySystem, const String& mimeType);

Lines 69-74 class VideoTrackPrivateAVFObjC; a/Source/WebCore/platform/graphics/avfoundation/objc/MediaPlayerPrivateAVFoundationObjC.h_sec1
- a/Source/WebCore/platform/graphics/avfoundation/objc/MediaPlayerPrivateAVFoundationObjC.h -3 / +1 lines
69		69
70	class MediaPlayerPrivateAVFoundationObjC : public MediaPlayerPrivateAVFoundation {	70	class MediaPlayerPrivateAVFoundationObjC : public MediaPlayerPrivateAVFoundation {
71	public:	71	public:
		72	explicit MediaPlayerPrivateAVFoundationObjC(MediaPlayer*);
72	virtual ~MediaPlayerPrivateAVFoundationObjC();	73	virtual ~MediaPlayerPrivateAVFoundationObjC();
73		74
74	static void registerMediaEngine(MediaEngineRegistrar);	75	static void registerMediaEngine(MediaEngineRegistrar);
Lines 131-140 public: a/Source/WebCore/platform/graphics/avfoundation/objc/MediaPlayerPrivateAVFoundationObjC.h_sec2
131	WeakPtr<MediaPlayerPrivateAVFoundationObjC> createWeakPtr() { return m_weakPtrFactory.createWeakPtr(); }	132	WeakPtr<MediaPlayerPrivateAVFoundationObjC> createWeakPtr() { return m_weakPtrFactory.createWeakPtr(); }
132		133
133	private:	134	private:
134	MediaPlayerPrivateAVFoundationObjC(MediaPlayer*);
135
136	// engine support	135	// engine support
137	static PassOwnPtr<MediaPlayerPrivateInterface> create(MediaPlayer*);
138	static void getSupportedTypes(HashSet<String>& types);	136	static void getSupportedTypes(HashSet<String>& types);
139	static MediaPlayer::SupportsType supportsType(const MediaEngineSupportParameters&);	137	static MediaPlayer::SupportsType supportsType(const MediaEngineSupportParameters&);
140	static bool supportsKeySystem(const String& keySystem, const String& mimeType);	138	static bool supportsKeySystem(const String& keySystem, const String& mimeType);

Lines 49-61 class MediaSourcePrivateAVFObjC; a/Source/WebCore/platform/graphics/avfoundation/objc/MediaPlayerPrivateMediaSourceAVFObjC.h_sec1
- a/Source/WebCore/platform/graphics/avfoundation/objc/MediaPlayerPrivateMediaSourceAVFObjC.h -3 / +1 lines
49		49
50	class MediaPlayerPrivateMediaSourceAVFObjC : public MediaPlayerPrivateInterface {	50	class MediaPlayerPrivateMediaSourceAVFObjC : public MediaPlayerPrivateInterface {
51	public:	51	public:
52	MediaPlayerPrivateMediaSourceAVFObjC(MediaPlayer*);	52	explicit MediaPlayerPrivateMediaSourceAVFObjC(MediaPlayer*);
53	virtual ~MediaPlayerPrivateMediaSourceAVFObjC();	53	virtual ~MediaPlayerPrivateMediaSourceAVFObjC();
54		54
55	static void registerMediaEngine(MediaEngineRegistrar);	55	static void registerMediaEngine(MediaEngineRegistrar);
56		56
57	// MediaPlayer Factory Methods
58	static PassOwnPtr<MediaPlayerPrivateInterface> create(MediaPlayer*);
59	static bool isAvailable();	57	static bool isAvailable();
60	static void getSupportedTypes(HashSet<String>& types);	58	static void getSupportedTypes(HashSet<String>& types);
61	static MediaPlayer::SupportsType supportsType(const MediaEngineSupportParameters&);	59	static MediaPlayer::SupportsType supportsType(const MediaEngineSupportParameters&);

Lines 195-206 MediaPlayerPrivateMediaSourceAVFObjC::~MediaPlayerPrivateMediaSourceAVFObjC() a/Source/WebCore/platform/graphics/avfoundation/objc/MediaPlayerPrivateMediaSourceAVFObjC.mm_sec1
- a/Source/WebCore/platform/graphics/avfoundation/objc/MediaPlayerPrivateMediaSourceAVFObjC.mm -6 / +1 lines
195	void MediaPlayerPrivateMediaSourceAVFObjC::registerMediaEngine(MediaEngineRegistrar registrar)	195	void MediaPlayerPrivateMediaSourceAVFObjC::registerMediaEngine(MediaEngineRegistrar registrar)
196	{	196	{
197	if (isAvailable())	197	if (isAvailable())
198	registrar(create, getSupportedTypes, supportsType, 0, 0, 0, 0);	198	registrar(MediaSourceAVFObjCPlayer, getSupportedTypes, supportsType, 0, 0, 0, 0);
199	}
200
201	PassOwnPtr<MediaPlayerPrivateInterface> MediaPlayerPrivateMediaSourceAVFObjC::create(MediaPlayer* player)
202	{
203	return adoptPtr(new MediaPlayerPrivateMediaSourceAVFObjC(player));
204	}	199	}
205		200
206	bool MediaPlayerPrivateMediaSourceAVFObjC::isAvailable()	201	bool MediaPlayerPrivateMediaSourceAVFObjC::isAvailable()

Lines 138-152 void MediaPlayerPrivateGStreamer::setAudioStreamProperties(GObject* object) a/Source/WebCore/platform/graphics/gstreamer/MediaPlayerPrivateGStreamer.cpp_sec1
- a/Source/WebCore/platform/graphics/gstreamer/MediaPlayerPrivateGStreamer.cpp -6 / +1 lines
138	LOG_MEDIA_MESSAGE("Set media.role as %s at %s", role, elementName.get());	138	LOG_MEDIA_MESSAGE("Set media.role as %s at %s", role, elementName.get());
139	}	139	}
140		140
141	PassOwnPtr<MediaPlayerPrivateInterface> MediaPlayerPrivateGStreamer::create(MediaPlayer* player)
142	{
143	return adoptPtr(new MediaPlayerPrivateGStreamer(player));
144	}
145
146	void MediaPlayerPrivateGStreamer::registerMediaEngine(MediaEngineRegistrar registrar)	141	void MediaPlayerPrivateGStreamer::registerMediaEngine(MediaEngineRegistrar registrar)
147	{	142	{
148	if (isAvailable())	143	if (isAvailable())
149	registrar(create, getSupportedTypes, supportsType, 0, 0, 0, 0);	144	registrar(GStreamerPlayer, getSupportedTypes, supportsType, 0, 0, 0, 0);
150	}	145	}
151		146
152	bool initializeGStreamerAndRegisterWebKitElements()	147	bool initializeGStreamerAndRegisterWebKitElements()

Lines 57-63 class VideoTrackPrivateGStreamer; a/Source/WebCore/platform/graphics/gstreamer/MediaPlayerPrivateGStreamer.h_sec1
- a/Source/WebCore/platform/graphics/gstreamer/MediaPlayerPrivateGStreamer.h -4 / +2 lines
57		57
58	class MediaPlayerPrivateGStreamer : public MediaPlayerPrivateGStreamerBase {	58	class MediaPlayerPrivateGStreamer : public MediaPlayerPrivateGStreamerBase {
59	public:	59	public:
		60	explicit MediaPlayerPrivateGStreamer(MediaPlayer*);
60	~MediaPlayerPrivateGStreamer();	61	~MediaPlayerPrivateGStreamer();
		62
61	static void registerMediaEngine(MediaEngineRegistrar);	63	static void registerMediaEngine(MediaEngineRegistrar);
62	gboolean handleMessage(GstMessage*);	64	gboolean handleMessage(GstMessage*);
63	void handlePluginInstallerResult(GstInstallPluginsReturn);	65	void handlePluginInstallerResult(GstInstallPluginsReturn);
Lines 126-135 public: a/Source/WebCore/platform/graphics/gstreamer/MediaPlayerPrivateGStreamer.h_sec2
126	bool changePipelineState(GstState);	128	bool changePipelineState(GstState);
127		129
128	private:	130	private:
129	MediaPlayerPrivateGStreamer(MediaPlayer*);
130
131	static PassOwnPtr<MediaPlayerPrivateInterface> create(MediaPlayer*);
132
133	static void getSupportedTypes(HashSet<String>&);	131	static void getSupportedTypes(HashSet<String>&);
134	static MediaPlayer::SupportsType supportsType(const MediaEngineSupportParameters&);	132	static MediaPlayer::SupportsType supportsType(const MediaEngineSupportParameters&);
135		133

Lines 50-55 namespace WebCore { a/Source/WebCore/platform/graphics/mac/MediaPlayerPrivateQTKit.h_sec1
- a/Source/WebCore/platform/graphics/mac/MediaPlayerPrivateQTKit.h -4 / +1 lines
50		50
51	class MediaPlayerPrivateQTKit : public MediaPlayerPrivateInterface {	51	class MediaPlayerPrivateQTKit : public MediaPlayerPrivateInterface {
52	public:	52	public:
		53	explicit MediaPlayerPrivateQTKit(MediaPlayer*);
53	~MediaPlayerPrivateQTKit();	54	~MediaPlayerPrivateQTKit();
54	WEBCORE_EXPORT static void registerMediaEngine(MediaEngineRegistrar);	55	WEBCORE_EXPORT static void registerMediaEngine(MediaEngineRegistrar);
55		56
Lines 63-72 public: a/Source/WebCore/platform/graphics/mac/MediaPlayerPrivateQTKit.h_sec2
63	void layerHostChanged(PlatformLayer* rootLayer);	64	void layerHostChanged(PlatformLayer* rootLayer);
64		65
65	private:	66	private:
66	MediaPlayerPrivateQTKit(MediaPlayer*);
67
68	// engine support
69	static PassOwnPtr<MediaPlayerPrivateInterface> create(MediaPlayer*);
70	static void getSupportedTypes(HashSet<String>& types);	67	static void getSupportedTypes(HashSet<String>& types);
71	static MediaPlayer::SupportsType supportsType(const MediaEngineSupportParameters&);	68	static MediaPlayer::SupportsType supportsType(const MediaEngineSupportParameters&);
72		69

Lines 41-55 MediaPlayerPrivateMediaFoundation::MediaPlayerPrivateMediaFoundation(MediaPlayer a/Source/WebCore/platform/graphics/win/MediaPlayerPrivateMediaFoundation.cpp_sec1
- a/Source/WebCore/platform/graphics/win/MediaPlayerPrivateMediaFoundation.cpp -6 / +1 lines
41	{	41	{
42	}	42	}
43		43
44	PassOwnPtr<MediaPlayerPrivateInterface> MediaPlayerPrivateMediaFoundation::create(MediaPlayer* player)
45	{
46	return adoptPtr(new MediaPlayerPrivateMediaFoundation(player));
47	}
48
49	void MediaPlayerPrivateMediaFoundation::registerMediaEngine(MediaEngineRegistrar registrar)	44	void MediaPlayerPrivateMediaFoundation::registerMediaEngine(MediaEngineRegistrar registrar)
50	{	45	{
51	if (isAvailable())	46	if (isAvailable())
52	registrar(create, getSupportedTypes, supportsType, 0, 0, 0, 0);	47	registrar(MediaFoundationPlayer, getSupportedTypes, supportsType, 0, 0, 0, 0);
53	}	48	}
54		49
55	bool MediaPlayerPrivateMediaFoundation::isAvailable()	50	bool MediaPlayerPrivateMediaFoundation::isAvailable()

Lines 30-39 namespace WebCore { a/Source/WebCore/platform/graphics/win/MediaPlayerPrivateMediaFoundation.h_sec1
- a/Source/WebCore/platform/graphics/win/MediaPlayerPrivateMediaFoundation.h -2 / +1 lines
30		30
31	class MediaPlayerPrivateMediaFoundation : public MediaPlayerPrivateInterface {	31	class MediaPlayerPrivateMediaFoundation : public MediaPlayerPrivateInterface {
32	public:	32	public:
33	MediaPlayerPrivateMediaFoundation(MediaPlayer*);	33	explicit MediaPlayerPrivateMediaFoundation(MediaPlayer*);
34	static void registerMediaEngine(MediaEngineRegistrar);	34	static void registerMediaEngine(MediaEngineRegistrar);
35		35
36	static PassOwnPtr<MediaPlayerPrivateInterface> create(MediaPlayer*);
37	static void getSupportedTypes(HashSet<String>& types);	36	static void getSupportedTypes(HashSet<String>& types);
38	static MediaPlayer::SupportsType supportsType(const MediaEngineSupportParameters&);	37	static MediaPlayer::SupportsType supportsType(const MediaEngineSupportParameters&);
39	static bool isAvailable();	38	static bool isAvailable();

Lines 41-52 namespace WebCore { a/Source/WebCore/platform/mock/mediasource/MockMediaPlayerMediaSource.cpp_sec1
- a/Source/WebCore/platform/mock/mediasource/MockMediaPlayerMediaSource.cpp -6 / +1 lines
41	// MediaPlayer Enigne Support	41	// MediaPlayer Enigne Support
42	void MockMediaPlayerMediaSource::registerMediaEngine(MediaEngineRegistrar registrar)	42	void MockMediaPlayerMediaSource::registerMediaEngine(MediaEngineRegistrar registrar)
43	{	43	{
44	registrar(create, getSupportedTypes, supportsType, 0, 0, 0, 0);	44	registrar(MockMediaSourcePlayer, getSupportedTypes, supportsType, 0, 0, 0, 0);
45	}
46
47	PassOwnPtr<MediaPlayerPrivateInterface> MockMediaPlayerMediaSource::create(MediaPlayer* player)
48	{
49	return adoptPtr(new MockMediaPlayerMediaSource(player));
50	}	45	}
51		46
52	static HashSet<String> mimeTypeCache()	47	static HashSet<String> mimeTypeCache()