Attachment #230567 for bug #132165

View Details Raw Unified Return to Bug 132165

| Differences between



2014-04-30  Gyuyoung Kim  <gyuyoung.kim@samsung.com>

        Convert OwnPtr and PassOwnPtr uses to std::unique_ptr in Supplement
        https://bugs.webkit.org/show_bug.cgi?id=132165

        Reviewed by NOBODY (OOPS!).

        According to convert from PassOwnPtr to std::unique_ptr, provideTo() callers also begin
        to use std::make_unique.

        * Modules/battery/BatteryController.cpp:
        (WebCore::provideBatteryTo):
        * Modules/battery/BatteryController.h:
        * Modules/battery/NavigatorBattery.cpp:
        (WebCore::NavigatorBattery::from):
        * Modules/gamepad/NavigatorGamepad.cpp:
        (WebCore::NavigatorGamepad::from):
        * Modules/geolocation/GeolocationController.cpp:
        (WebCore::provideGeolocationTo):
        * Modules/geolocation/GeolocationController.h:
        * Modules/geolocation/NavigatorGeolocation.cpp:
        (WebCore::NavigatorGeolocation::from):
        * Modules/indexeddb/DOMWindowIndexedDatabase.cpp:
        (WebCore::DOMWindowIndexedDatabase::from):
        * Modules/indexeddb/PageGroupIndexedDatabase.cpp:
        (WebCore::PageGroupIndexedDatabase::from):
        * Modules/indexeddb/WorkerGlobalScopeIndexedDatabase.cpp:
        (WebCore::WorkerGlobalScopeIndexedDatabase::from):
        * Modules/mediastream/UserMediaController.cpp:
        (WebCore::provideUserMediaTo):
        (WebCore::UserMediaController::create): Deleted.
        * Modules/mediastream/UserMediaController.h:
        * Modules/navigatorcontentutils/NavigatorContentUtils.cpp:
        (WebCore::provideNavigatorContentUtilsTo):
        (WebCore::NavigatorContentUtils::create): Deleted.
        * Modules/navigatorcontentutils/NavigatorContentUtils.h:
        * Modules/notifications/DOMWindowNotifications.cpp:
        (WebCore::DOMWindowNotifications::from):
        * Modules/notifications/NotificationController.cpp:
        (WebCore::provideNotification):
        (WebCore::NotificationController::create): Deleted.
        * Modules/notifications/NotificationController.h:
        * Modules/notifications/WorkerGlobalScopeNotifications.cpp:
        (WebCore::WorkerGlobalScopeNotifications::from):
        * Modules/proximity/DeviceProximityController.cpp:
        (WebCore::provideDeviceProximityTo):
        (WebCore::DeviceProximityController::create): Deleted.
        * Modules/proximity/DeviceProximityController.h:
        * Modules/quota/DOMWindowQuota.cpp:
        (WebCore::DOMWindowQuota::from):
        * Modules/quota/NavigatorStorageQuota.cpp:
        (WebCore::NavigatorStorageQuota::from):
        * Modules/quota/WorkerNavigatorStorageQuota.cpp:
        (WebCore::WorkerNavigatorStorageQuota::from):
        * Modules/speech/DOMWindowSpeechSynthesis.cpp:
        (WebCore::DOMWindowSpeechSynthesis::from):
        * Modules/speech/SpeechRecognitionController.cpp:
        (WebCore::provideSpeechRecognitionTo):
        * Modules/vibration/Vibration.cpp:
        (WebCore::provideVibrationTo):
        (WebCore::Vibration::create): Deleted.
        * Modules/vibration/Vibration.h:
        * dom/DeviceMotionController.cpp:
        (WebCore::provideDeviceMotionTo):
        (WebCore::DeviceMotionController::create): Deleted.
        * dom/DeviceMotionController.h:
        * dom/DeviceOrientationController.cpp:
        (WebCore::provideDeviceOrientationTo):
        (WebCore::DeviceOrientationController::create): Deleted.
        * dom/DeviceOrientationController.h:
        * page/SpeechInput.cpp:
        (WebCore::provideSpeechInputTo):
        (WebCore::SpeechInput::create): Deleted.
        * page/SpeechInput.h:
        * platform/Supplementable.h:
        (WebCore::Supplement::provideTo):
        (WebCore::Supplementable::provideSupplement):
        * testing/InternalSettings.cpp:
        (WebCore::InternalSettings::from):

2014-04-30  Simon Fraser  <simon.fraser@apple.com>

        More iOS build fixing. MediaPlayerPrivateIOS is defunct and can be removed.



    m_client->batteryControllerDestroyed();
}

PassOwnPtr<BatteryController> BatteryController::create(BatteryClient* client)
{
    return adoptPtr(new BatteryController(client));
}

void BatteryController::addListener(BatteryManager* batteryManager)
{
    m_listeners.append(batteryManager);


void provideBatteryTo(Page* page, BatteryClient* client)
{
    Supplement<Page>::provideTo(page, BatteryController::supplementName(), std::make_unique<BatteryController>(client));
}

}




class BatteryController : public Supplement<Page> {
public:
    explicit BatteryController(BatteryClient*);
    ~BatteryController();

    static PassOwnPtr<BatteryController> create(BatteryClient*);

    void addListener(BatteryManager*);
    void removeListener(BatteryManager*);
    void updateBatteryStatus(PassRefPtr<BatteryStatus>);

private:
    typedef Vector<BatteryManager*> ListenerVector;

    explicit BatteryController(BatteryClient*);

    BatteryClient* m_client;
    ListenerVector m_listeners;




{
    NavigatorBattery* supplement = static_cast<NavigatorBattery*>(Supplement<Navigator>::from(navigator, supplementName()));
    if (!supplement) {
        auto newSupplement = std::make_unique<NavigatorBattery>();
        supplement = newSupplement.get();
        provideTo(navigator, supplementName(), std::move(newSupplement));
    }
    return supplement;
}




class NavigatorBattery : public Supplement<Navigator> {
public:
    NavigatorBattery();
    virtual ~NavigatorBattery();

    static NavigatorBattery* from(Navigator*);
    static BatteryManager* webkitBattery(Navigator*);

 private:
    NavigatorBattery();
    static const char* supplementName();

    RefPtr<BatteryManager> m_batteryManager;



{
    NavigatorGamepad* supplement = static_cast<NavigatorGamepad*>(Supplement<Navigator>::from(navigator, supplementName()));
    if (!supplement) {
        auto newSupplement = std::make_unique<NavigatorGamepad>();
        supplement = newSupplement.get();
        provideTo(navigator, supplementName(), std::move(newSupplement));
    }
    return supplement;
}




class NavigatorGamepad : public Supplement<Navigator> {
public:
    NavigatorGamepad();
    virtual ~NavigatorGamepad();

    static NavigatorGamepad* from(Navigator*);

    static GamepadList* webkitGetGamepads(Navigator*);

    GamepadList* gamepads();

private:
    NavigatorGamepad();
    static const char* supplementName();

    RefPtr<GamepadList> m_gamepads;

Lines 132-138 const char* GeolocationController::supplementName() a/Source/WebCore/Modules/geolocation/GeolocationController.cpp_sec1
- a/Source/WebCore/Modules/geolocation/GeolocationController.cpp -1 / +1 lines
132		132
133	void provideGeolocationTo(Page* page, GeolocationClient* client)	133	void provideGeolocationTo(Page* page, GeolocationClient* client)
134	{	134	{
135	Supplement<Page>::provideTo(page, GeolocationController::supplementName(), GeolocationController::create(client));	135	Supplement<Page>::provideTo(page, GeolocationController::supplementName(), std::make_unique<GeolocationController>(client));
136	}	136	}
137		137
138	} // namespace WebCore	138	} // namespace WebCore



class GeolocationController : public Supplement<Page> {
    WTF_MAKE_NONCOPYABLE(GeolocationController);
public:
    explicit GeolocationController(GeolocationClient*);
    ~GeolocationController();

    static PassOwnPtr<GeolocationController> create(GeolocationClient*);

    static GeolocationController* from(Page* page) { return static_cast<GeolocationController*>(Supplement<Page>::from(page, supplementName())); }

private:
    GeolocationController(GeolocationClient*);

    GeolocationClient* m_client;

    RefPtr<GeolocationPosition> m_lastPosition;



{
    NavigatorGeolocation* supplement = static_cast<NavigatorGeolocation*>(Supplement<Navigator>::from(navigator, supplementName()));
    if (!supplement) {
        auto newSupplement = std::make_unique<NavigatorGeolocation>(navigator->frame());
        supplement = newSupplement.get();
        provideTo(navigator, supplementName(), std::move(newSupplement));
    }
    return supplement;
}




class NavigatorGeolocation : public Supplement<Navigator>, public DOMWindowProperty {
public:
    explicit NavigatorGeolocation(Frame*);
    virtual ~NavigatorGeolocation();
    static NavigatorGeolocation* from(Navigator*);


#endif // PLATFORM(IOS)

private:
    NavigatorGeolocation(Frame*);
    static const char* supplementName();

    mutable RefPtr<Geolocation> m_geolocation;



{
    DOMWindowIndexedDatabase* supplement = static_cast<DOMWindowIndexedDatabase*>(Supplement<DOMWindow>::from(window, supplementName()));
    if (!supplement) {
        auto newSupplement = std::make_unique<DOMWindowIndexedDatabase>(window);
        supplement = newSupplement.get();
        provideTo(window, supplementName(), std::move(newSupplement));
    }
    return supplement;
}




class DOMWindowIndexedDatabase : public DOMWindowProperty, public Supplement<DOMWindow> {
public:
    explicit DOMWindowIndexedDatabase(DOMWindow*);
    virtual ~DOMWindowIndexedDatabase();

    static DOMWindowIndexedDatabase* from(DOMWindow*);

    static IDBFactory* indexedDB(DOMWindow*);

    virtual void willDetachGlobalObjectFromFrame() override;

private:
    explicit DOMWindowIndexedDatabase(DOMWindow*);

    IDBFactory* indexedDB();
    static const char* supplementName();




{
    PageGroupIndexedDatabase* supplement = static_cast<PageGroupIndexedDatabase*>(Supplement<PageGroup>::from(&group, supplementName()));
    if (!supplement) {
        auto newSupplement = std::make_unique<PageGroupIndexedDatabase>(group.groupSettings().indexedDBDatabasePath());
        supplement = newSupplement.get();
        provideTo(&group, supplementName(), std::move(newSupplement));
    }
    return supplement;
}




class PageGroupIndexedDatabase : public Supplement<PageGroup> {
public:
    explicit PageGroupIndexedDatabase(const String& databaseDirectoryIdentifier);
    virtual ~PageGroupIndexedDatabase();

    static PageGroupIndexedDatabase* from(PageGroup&);

    IDBFactoryBackendInterface* factoryBackend();

private:
    explicit PageGroupIndexedDatabase(const String& databaseDirectoryIdentifier);
    static const char* supplementName();

    String m_databaseDirectoryIdentifier;



        if (groupSettings)
            databaseDirectoryIdentifier = groupSettings->indexedDBDatabasePath();

        auto newSupplement = std::make_unique<WorkerGlobalScopeIndexedDatabase>(databaseDirectoryIdentifier);
        supplement = newSupplement.get();
        provideTo(context, supplementName(), std::move(newSupplement));
    }
    return supplement;
}




class WorkerGlobalScopeIndexedDatabase : public Supplement<ScriptExecutionContext> {
public:
    explicit WorkerGlobalScopeIndexedDatabase(const String& databaseDirectoryIdentifier);
    virtual ~WorkerGlobalScopeIndexedDatabase();
    static WorkerGlobalScopeIndexedDatabase* from(ScriptExecutionContext*);

    static IDBFactory* indexedDB(ScriptExecutionContext*);

private:
    explicit WorkerGlobalScopeIndexedDatabase(const String& databaseDirectoryIdentifier);

    IDBFactory* indexedDB();
    static const char* supplementName();




    m_client->pageDestroyed();
}

PassOwnPtr<UserMediaController> UserMediaController::create(UserMediaClient* client)
{
    return adoptPtr(new UserMediaController(client));
}

void provideUserMediaTo(Page* page, UserMediaClient* client)
{
    if (!Supplement<Page>::from(page, UserMediaController::supplementName()))
        UserMediaController::provideTo(page, UserMediaController::supplementName(), std::make_unique<UserMediaController>(client));
}

} // namespace WebCore




class UserMediaController : public Supplement<Page> {
public:
    explicit UserMediaController(UserMediaClient*);
    ~UserMediaController();

    UserMediaClient* client() const { return m_client; }
    void requestPermission(PassRefPtr<UserMediaRequest>);
    void cancelRequest(UserMediaRequest*);

    static PassOwnPtr<UserMediaController> create(UserMediaClient*);
    static const char* supplementName();
    static UserMediaController* from(Page* page) { return static_cast<UserMediaController*>(Supplement<Page>::from(page, supplementName())); }

protected:
    explicit UserMediaController(UserMediaClient*);

private:
    UserMediaClient* m_client;
};



{
}

PassOwnPtr<NavigatorContentUtils> NavigatorContentUtils::create(std::unique_ptr<NavigatorContentUtilsClient> client)
{
    return adoptPtr(new NavigatorContentUtils(std::move(client)));
}

void NavigatorContentUtils::registerProtocolHandler(Navigator* navigator, const String& scheme, const String& url, const String& title, ExceptionCode& ec)
{
    if (!navigator->frame())


void provideNavigatorContentUtilsTo(Page* page, std::unique_ptr<NavigatorContentUtilsClient> client)
{
    NavigatorContentUtils::provideTo(page, NavigatorContentUtils::supplementName(), std::make_unique<NavigatorContentUtils>(std::move(client)));
}

} // namespace WebCore




class NavigatorContentUtils final : public Supplement<Page> {
public:
    explicit NavigatorContentUtils(std::unique_ptr<NavigatorContentUtilsClient> client)
        : m_client(std::move(client))
    { }

    virtual ~NavigatorContentUtils();

    static const char* supplementName();

    static void unregisterProtocolHandler(Navigator*, const String& scheme, const String& url, ExceptionCode&);
#endif

    static PassOwnPtr<NavigatorContentUtils> create(std::unique_ptr<NavigatorContentUtilsClient>);

private:
    explicit NavigatorContentUtils(std::unique_ptr<NavigatorContentUtilsClient> client)
        : m_client(std::move(client))
    { }

    NavigatorContentUtilsClient* client() { return m_client.get(); }

    std::unique_ptr<NavigatorContentUtilsClient> m_client;



{
    DOMWindowNotifications* supplement = static_cast<DOMWindowNotifications*>(Supplement<DOMWindow>::from(window, supplementName()));
    if (!supplement) {
        auto newSupplement = std::make_unique<DOMWindowNotifications>(window);
        supplement = newSupplement.get();
        provideTo(window, supplementName(), std::move(newSupplement));
    }
    return supplement;
}




class DOMWindowNotifications : public Supplement<DOMWindow>, public DOMWindowProperty {
public:
    explicit DOMWindowNotifications(DOMWindow*);
    virtual ~DOMWindowNotifications();

    static NotificationCenter* webkitNotifications(DOMWindow*);

    virtual void willDetachGlobalObjectFromFrame() override;

private:
    explicit DOMWindowNotifications(DOMWindow*);

    NotificationCenter* webkitNotifications();
    static const char* supplementName();




        m_client->notificationControllerDestroyed();
}

PassOwnPtr<NotificationController> NotificationController::create(NotificationClient* client)
{
    return adoptPtr(new NotificationController(client));
}

NotificationClient* NotificationController::clientFrom(Page* page)
{
    if (NotificationController* controller = NotificationController::from(page))


void provideNotification(Page* page, NotificationClient* client)
{
    NotificationController::provideTo(page, NotificationController::supplementName(), std::make_unique<NotificationController>(client));
}

} // namespace WebCore



class NotificationController : public Supplement<Page> {
    WTF_MAKE_NONCOPYABLE(NotificationController);
public:
    explicit NotificationController(NotificationClient*);
    ~NotificationController();

    static PassOwnPtr<NotificationController> create(NotificationClient*);
    static const char* supplementName();
    static NotificationController* from(Page* page) { return static_cast<NotificationController*>(Supplement<Page>::from(page, supplementName())); }
    static NotificationClient* clientFrom(Page*);

    NotificationClient* client() { return m_client; }
    
private:
    explicit NotificationController(NotificationClient*);

    NotificationClient* m_client;
};




{
    WorkerGlobalScopeNotifications* supplement = static_cast<WorkerGlobalScopeNotifications*>(Supplement<ScriptExecutionContext>::from(context, supplementName()));
    if (!supplement) {
        auto newSupplement = std::make_unique<WorkerGlobalScopeNotifications>(context);
        supplement = newSupplement.get();
        provideTo(context, supplementName(), std::move(newSupplement));
    }
    return supplement;
}




class WorkerGlobalScopeNotifications : public Supplement<ScriptExecutionContext> {
public:
    explicit WorkerGlobalScopeNotifications(WorkerGlobalScope*);
    virtual ~WorkerGlobalScopeNotifications();

    static NotificationCenter* webkitNotifications(WorkerGlobalScope*);
    static WorkerGlobalScopeNotifications* from(WorkerGlobalScope*);

private:
    explicit WorkerGlobalScopeNotifications(WorkerGlobalScope*);

    NotificationCenter* webkitNotifications();
    static const char* supplementName();




    ASSERT(m_client);
}

PassOwnPtr<DeviceProximityController> DeviceProximityController::create(DeviceProximityClient* client)
{
    return adoptPtr(new DeviceProximityController(client));
}

void DeviceProximityController::didChangeDeviceProximity(const double value, const double min, const double max)
{
    ASSERT(value >= min && value <= max);


void provideDeviceProximityTo(Page* page, DeviceProximityClient* client)
{
    DeviceProximityController::provideTo(page, DeviceProximityController::supplementName(), std::make_unique<DeviceProximityController>(client));
}

} // namespace WebCore




class DeviceProximityController : public DeviceController {
public:
    explicit DeviceProximityController(DeviceProximityClient*);
    ~DeviceProximityController() { }

    static PassOwnPtr<DeviceProximityController> create(DeviceProximityClient*);

    void didChangeDeviceProximity(const double value, const double min, const double max);
    DeviceProximityClient* deviceProximityClient();


    static const char* supplementName();
    static DeviceProximityController* from(Page*);
    static bool isActiveAt(Page*);

private:
    explicit DeviceProximityController(DeviceProximityClient*);
};

} // namespace WebCore



{
    DOMWindowQuota* supplement = static_cast<DOMWindowQuota*>(Supplement<DOMWindow>::from(window, supplementName()));
    if (!supplement) {
        auto newSupplement = std::make_unique<DOMWindowQuota>(window);
        supplement = newSupplement.get();
        provideTo(window, supplementName(), std::move(newSupplement));
    }
    return supplement;
}




class DOMWindowQuota : public Supplement<DOMWindow>, public DOMWindowProperty {
public:
    explicit DOMWindowQuota(DOMWindow*);
    virtual ~DOMWindowQuota();
    static DOMWindowQuota* from(DOMWindow*);
    static StorageInfo* webkitStorageInfo(DOMWindow*);
    StorageInfo* webkitStorageInfo() const;

private:
    explicit DOMWindowQuota(DOMWindow*);
    static const char* supplementName();

    mutable RefPtr<StorageInfo> m_storageInfo;



{
    NavigatorStorageQuota* supplement = static_cast<NavigatorStorageQuota*>(Supplement<Navigator>::from(navigator, supplementName()));
    if (!supplement) {
        auto newSupplement = std::make_unique<NavigatorStorageQuota>(window);
        supplement = newSupplement.get();
        provideTo(navigator, supplementName(), std::move(newSupplement));
    }
    return supplement;
}




class NavigatorStorageQuota : public Supplement<Navigator>, public DOMWindowProperty {
public:
    explicit NavigatorStorageQuota(Frame*);
    virtual ~NavigatorStorageQuota();
    static NavigatorStorageQuota* from(Navigator*);


    StorageQuota* webkitPersistentStorage() const;

private:
    explicit NavigatorStorageQuota(Frame*);
    static const char* supplementName();

    mutable RefPtr<StorageQuota> m_temporaryStorage;



{
    WorkerNavigatorStorageQuota* supplement = static_cast<WorkerNavigatorStorageQuota*>(Supplement<WorkerNavigator>::from(navigator, supplementName()));
    if (!supplement) {
        auto newSupplement = std::make_unique<WorkerNavigatorStorageQuota>(window);
        supplement = newSupplement.get();
        provideTo(navigator, supplementName(), std::move(newSupplement));
    }
    return supplement;
}




class WorkerNavigatorStorageQuota : public Supplement<WorkerNavigator> {
public:
    explicit WorkerNavigatorStorageQuota();
    virtual ~WorkerNavigatorStorageQuota();
    static WorkerNavigatorStorageQuota* from(WorkerNavigator*);


    StorageQuota* webkitPersistentStorage() const;

private:
    explicit WorkerNavigatorStorageQuota();
    static const char* supplementName();

    mutable RefPtr<StorageQuota> m_temporaryStorage;



{
    DOMWindowSpeechSynthesis* supplement = static_cast<DOMWindowSpeechSynthesis*>(Supplement<DOMWindow>::from(window, supplementName()));
    if (!supplement) {
        auto newSupplement = std::make_unique<DOMWindowSpeechSynthesis>(window);
        supplement = newSupplement.get();
        provideTo(window, supplementName(), std::move(newSupplement));
    }
    return supplement;
}




class DOMWindowSpeechSynthesis : public Supplement<DOMWindow>, public DOMWindowProperty {
public:
    explicit DOMWindowSpeechSynthesis(DOMWindow*);
    virtual ~DOMWindowSpeechSynthesis();
    
    static SpeechSynthesis* speechSynthesis(DOMWindow*);
    static DOMWindowSpeechSynthesis* from(DOMWindow*);
    
private:
    explicit DOMWindowSpeechSynthesis(DOMWindow*);
    
    SpeechSynthesis* speechSynthesis();
    static const char* supplementName();
    

Lines 47-53 SpeechRecognitionController::~SpeechRecognitionController() a/Source/WebCore/Modules/speech/SpeechRecognitionController.cpp_sec1
- a/Source/WebCore/Modules/speech/SpeechRecognitionController.cpp -1 / +1 lines
47		47
48	void provideSpeechRecognitionTo(Page* page, SpeechRecognitionClient* client)	48	void provideSpeechRecognitionTo(Page* page, SpeechRecognitionClient* client)
49	{	49	{
50	SpeechRecognitionController::provideTo(page, SpeechRecognitionController::supplementName(), SpeechRecognitionController::create(client));	50	SpeechRecognitionController::provideTo(page, SpeechRecognitionController::supplementName(), std::make_unique<SpeechRecognitionController>(client));
51	}	51	}
52		52
53	} // namespace WebCore	53	} // namespace WebCore



    m_vibrationClient->vibrationDestroyed();
}

PassOwnPtr<Vibration> Vibration::create(VibrationClient* client)
{
    return adoptPtr(new Vibration(client));
}

bool Vibration::vibrate(const VibrationPattern& pattern)
{
    VibrationPattern& sanitized = const_cast<VibrationPattern&>(pattern);


void provideVibrationTo(Page* page, VibrationClient* client)
{
    Vibration::provideTo(page, Vibration::supplementName(), std::make_unique<Vibration>(client));
}

} // namespace WebCore



    explicit Vibration(VibrationClient*);
    ~Vibration();

    static PassOwnPtr<Vibration> create(VibrationClient*);

    bool vibrate(const VibrationPattern&);
    // FIXME: When a visibilitychange event is dispatched while vibrating, the vibration should be canceled.
    void cancelVibration();



    deviceMotionClient()->setController(this);
}

PassOwnPtr<DeviceMotionController> DeviceMotionController::create(DeviceMotionClient* client)
{
    return adoptPtr(new DeviceMotionController(client));
}

#if PLATFORM(IOS)
// FIXME: We should look to reconcile the iOS and OpenSource differences with this class
// so that we can either remove these methods or remove the PLATFORM(IOS)-guard.


void provideDeviceMotionTo(Page* page, DeviceMotionClient* client)
{
    DeviceMotionController::provideTo(page, DeviceMotionController::supplementName(), std::make_unique<DeviceMotionController>(client));
}

} // namespace WebCore



class DeviceMotionController : public DeviceController {
    WTF_MAKE_NONCOPYABLE(DeviceMotionController);
public:
    explicit DeviceMotionController(DeviceMotionClient*);
    ~DeviceMotionController() { };

    static PassOwnPtr<DeviceMotionController> create(DeviceMotionClient*);

#if PLATFORM(IOS)
    // FIXME: We should look to reconcile the iOS and OpenSource differences with this class
    // so that we can either remove these methods or remove the PLATFORM(IOS)-guard.

    static const char* supplementName();
    static DeviceMotionController* from(Page*);
    static bool isActiveAt(Page*);

private:
    explicit DeviceMotionController(DeviceMotionClient*);
};

} // namespace WebCore



#endif
}

PassOwnPtr<DeviceOrientationController> DeviceOrientationController::create(DeviceOrientationClient* client)
{
    return adoptPtr(new DeviceOrientationController(client));
}

void DeviceOrientationController::didChangeDeviceOrientation(DeviceOrientationData* orientation)
{
    dispatchDeviceEvent(DeviceOrientationEvent::create(eventNames().deviceorientationEvent, orientation));


void provideDeviceOrientationTo(Page* page, DeviceOrientationClient* client)
{
    DeviceOrientationController::provideTo(page, DeviceOrientationController::supplementName(), std::make_unique<DeviceOrientationController>(client));
}

} // namespace WebCore



class DeviceOrientationController : public DeviceController {
    WTF_MAKE_NONCOPYABLE(DeviceOrientationController);
public:
    explicit DeviceOrientationController(DeviceOrientationClient*);
    ~DeviceOrientationController() { };

    static PassOwnPtr<DeviceOrientationController> create(DeviceOrientationClient*);

    void didChangeDeviceOrientation(DeviceOrientationData*);
    DeviceOrientationClient* deviceOrientationClient();


    static const char* supplementName();
    static DeviceOrientationController* from(Page*);
    static bool isActiveAt(Page*);

private:
    DeviceOrientationController(DeviceOrientationClient*);
};

} // namespace WebCore



    m_client->setListener(0);
}

PassOwnPtr<SpeechInput> SpeechInput::create(SpeechInputClient* client)
{
    return adoptPtr(new SpeechInput(client));
}

int SpeechInput::registerListener(SpeechInputListener* listener)
{
#if defined(DEBUG)


void provideSpeechInputTo(Page* page, SpeechInputClient* client)
{
    SpeechInput::provideTo(page, SpeechInput::supplementName(), std::make_unique<SpeechInput>(client));
}

} // namespace WebCore



                    public Supplement<Page> {
    WTF_MAKE_NONCOPYABLE(SpeechInput);
public:
    explicit SpeechInput(SpeechInputClient*);
    virtual ~SpeechInput();

    static PassOwnPtr<SpeechInput> create(SpeechInputClient*);
    static const char* supplementName();
    static SpeechInput* from(Page* page) { return static_cast<SpeechInput*>(Supplement<Page>::from(page, supplementName())); }


    virtual void setRecognitionResult(int, const SpeechInputResultArray&);

private:
    explicit SpeechInput(SpeechInputClient*);

    SpeechInputClient* m_client;
    HashMap<int, SpeechInputListener*> m_listeners;
    int m_nextListenerId;



    virtual bool isRefCountedWrapper() const { return false; }
#endif

    static void provideTo(Supplementable<T>* host, const char* key, std::unique_ptr<Supplement<T>> supplement)
    {
        host->provideSupplement(key, std::move(supplement));
    }

    static Supplement<T>* from(Supplementable<T>* host, const char* key)

template<typename T>
class Supplementable {
public:
    void provideSupplement(const char* key, std::unique_ptr<Supplement<T>> supplement)
    {
        ASSERT(canAccessThreadLocalDataForThread(m_threadId));
        ASSERT(!m_supplements.get(key));
        m_supplements.set(key, std::move(supplement));
    }

    void removeSupplement(const char* key)

#endif

private:
    typedef HashMap<const char*, std::unique_ptr<Supplement<T>>, PtrHash<const char*>> SupplementMap;
    SupplementMap m_supplements;
#if !ASSERT_DISABLED
    ThreadIdentifier m_threadId;

Lines 176-182 const char* InternalSettings::supplementName() a/Source/WebCore/testing/InternalSettings.cpp_sec1
- a/Source/WebCore/testing/InternalSettings.cpp -1 / +1 lines
176	InternalSettings* InternalSettings::from(Page* page)	176	InternalSettings* InternalSettings::from(Page* page)
177	{	177	{
178	if (!Supplement<Page>::from(page, supplementName()))	178	if (!Supplement<Page>::from(page, supplementName()))
179	Supplement<Page>::provideTo(page, supplementName(), adoptPtr(new InternalSettingsWrapper(page)));	179	Supplement<Page>::provideTo(page, supplementName(), std::make_unique<InternalSettingsWrapper>(page));
180	return static_cast<InternalSettingsWrapper*>(Supplement<Page>::from(page, supplementName()))->internalSettings();	180	return static_cast<InternalSettingsWrapper*>(Supplement<Page>::from(page, supplementName()))->internalSettings();
181	}	181	}
182		182

Return to Bug 132165

Lines 42-52 BatteryController::~BatteryController() a/Source/WebCore/Modules/battery/BatteryController.cpp_sec1
- a/Source/WebCore/Modules/battery/BatteryController.cpp -6 / +1 lines
42	m_client->batteryControllerDestroyed();	42	m_client->batteryControllerDestroyed();
43	}	43	}
44		44
45	PassOwnPtr<BatteryController> BatteryController::create(BatteryClient* client)
46	{
47	return adoptPtr(new BatteryController(client));
48	}
49
50	void BatteryController::addListener(BatteryManager* batteryManager)	45	void BatteryController::addListener(BatteryManager* batteryManager)
51	{	46	{
52	m_listeners.append(batteryManager);	47	m_listeners.append(batteryManager);
Lines 102-108 const char* BatteryController::supplementName() a/Source/WebCore/Modules/battery/BatteryController.cpp_sec2
102		97
103	void provideBatteryTo(Page* page, BatteryClient* client)	98	void provideBatteryTo(Page* page, BatteryClient* client)
104	{	99	{
105	Supplement<Page>::provideTo(page, BatteryController::supplementName(), BatteryController::create(client));	100	Supplement<Page>::provideTo(page, BatteryController::supplementName(), std::make_unique<BatteryController>(client));
106	}	101	}
107		102
108	}	103	}

Lines 56-63 NavigatorBattery* NavigatorBattery::from(Navigator* navigator) a/Source/WebCore/Modules/battery/NavigatorBattery.cpp_sec1
- a/Source/WebCore/Modules/battery/NavigatorBattery.cpp -2 / +3 lines
56	{	56	{
57	NavigatorBattery* supplement = static_cast<NavigatorBattery*>(Supplement<Navigator>::from(navigator, supplementName()));	57	NavigatorBattery* supplement = static_cast<NavigatorBattery*>(Supplement<Navigator>::from(navigator, supplementName()));
58	if (!supplement) {	58	if (!supplement) {
59	supplement = new NavigatorBattery();	59	auto newSupplement = std::make_unique<NavigatorBattery>();
60	provideTo(navigator, supplementName(), adoptPtr(supplement));	60	supplement = newSupplement.get();
		61	provideTo(navigator, supplementName(), std::move(newSupplement));
61	}	62	}
62	return supplement;	63	return supplement;
63	}	64	}

Lines 56-63 DOMWindowIndexedDatabase* DOMWindowIndexedDatabase::from(DOMWindow* window) a/Source/WebCore/Modules/indexeddb/DOMWindowIndexedDatabase.cpp_sec1
- a/Source/WebCore/Modules/indexeddb/DOMWindowIndexedDatabase.cpp -2 / +3 lines
56	{	56	{
57	DOMWindowIndexedDatabase* supplement = static_cast<DOMWindowIndexedDatabase*>(Supplement<DOMWindow>::from(window, supplementName()));	57	DOMWindowIndexedDatabase* supplement = static_cast<DOMWindowIndexedDatabase*>(Supplement<DOMWindow>::from(window, supplementName()));
58	if (!supplement) {	58	if (!supplement) {
59	supplement = new DOMWindowIndexedDatabase(window);	59	auto newSupplement = std::make_unique<DOMWindowIndexedDatabase>(window);
60	provideTo(window, supplementName(), adoptPtr(supplement));	60	supplement = newSupplement.get();
		61	provideTo(window, supplementName(), std::move(newSupplement));
61	}	62	}
62	return supplement;	63	return supplement;
63	}	64	}

Lines 61-68 WorkerGlobalScopeIndexedDatabase* WorkerGlobalScopeIndexedDatabase::from(ScriptE a/Source/WebCore/Modules/indexeddb/WorkerGlobalScopeIndexedDatabase.cpp_sec1
- a/Source/WebCore/Modules/indexeddb/WorkerGlobalScopeIndexedDatabase.cpp -2 / +3 lines
61	if (groupSettings)	61	if (groupSettings)
62	databaseDirectoryIdentifier = groupSettings->indexedDBDatabasePath();	62	databaseDirectoryIdentifier = groupSettings->indexedDBDatabasePath();
63		63
64	supplement = new WorkerGlobalScopeIndexedDatabase(databaseDirectoryIdentifier);	64	auto newSupplement = std::make_unique<WorkerGlobalScopeIndexedDatabase>(databaseDirectoryIdentifier);
65	provideTo(context, supplementName(), adoptPtr(supplement));	65	supplement = newSupplement.get();
		66	provideTo(context, supplementName(), std::move(newSupplement));
66	}	67	}
67	return supplement;	68	return supplement;
68	}	69	}

Lines 126-136 NavigatorContentUtils::~NavigatorContentUtils() a/Source/WebCore/Modules/navigatorcontentutils/NavigatorContentUtils.cpp_sec1
- a/Source/WebCore/Modules/navigatorcontentutils/NavigatorContentUtils.cpp -6 / +1 lines
126	{	126	{
127	}	127	}
128		128
129	PassOwnPtr<NavigatorContentUtils> NavigatorContentUtils::create(std::unique_ptr<NavigatorContentUtilsClient> client)
130	{
131	return adoptPtr(new NavigatorContentUtils(std::move(client)));
132	}
133
134	void NavigatorContentUtils::registerProtocolHandler(Navigator* navigator, const String& scheme, const String& url, const String& title, ExceptionCode& ec)	129	void NavigatorContentUtils::registerProtocolHandler(Navigator* navigator, const String& scheme, const String& url, const String& title, ExceptionCode& ec)
135	{	130	{
136	if (!navigator->frame())	131	if (!navigator->frame())
Lines 209-215 const char* NavigatorContentUtils::supplementName() a/Source/WebCore/Modules/navigatorcontentutils/NavigatorContentUtils.cpp_sec2
209		204
210	void provideNavigatorContentUtilsTo(Page* page, std::unique_ptr<NavigatorContentUtilsClient> client)	205	void provideNavigatorContentUtilsTo(Page* page, std::unique_ptr<NavigatorContentUtilsClient> client)
211	{	206	{
212	NavigatorContentUtils::provideTo(page, NavigatorContentUtils::supplementName(), NavigatorContentUtils::create(std::move(client)));	207	NavigatorContentUtils::provideTo(page, NavigatorContentUtils::supplementName(), std::make_unique<NavigatorContentUtils>(std::move(client)));
213	}	208	}
214		209
215	} // namespace WebCore	210	} // namespace WebCore

Lines 1-3 a/Source/WebCore/ChangeLog_sec1
- a/Source/WebCore/ChangeLog +80 lines
		1	2014-04-30 Gyuyoung Kim <gyuyoung.kim@samsung.com>
		2
		3	Convert OwnPtr and PassOwnPtr uses to std::unique_ptr in Supplement
		4	https://bugs.webkit.org/show_bug.cgi?id=132165
		5
		6	Reviewed by NOBODY (OOPS!).
		7
		8	According to convert from PassOwnPtr to std::unique_ptr, provideTo() callers also begin
		9	to use std::make_unique.
		10
		11	* Modules/battery/BatteryController.cpp:
		12	(WebCore::provideBatteryTo):
		13	* Modules/battery/BatteryController.h:
		14	* Modules/battery/NavigatorBattery.cpp:
		15	(WebCore::NavigatorBattery::from):
		16	* Modules/gamepad/NavigatorGamepad.cpp:
		17	(WebCore::NavigatorGamepad::from):
		18	* Modules/geolocation/GeolocationController.cpp:
		19	(WebCore::provideGeolocationTo):
		20	* Modules/geolocation/GeolocationController.h:
		21	* Modules/geolocation/NavigatorGeolocation.cpp:
		22	(WebCore::NavigatorGeolocation::from):
		23	* Modules/indexeddb/DOMWindowIndexedDatabase.cpp:
		24	(WebCore::DOMWindowIndexedDatabase::from):
		25	* Modules/indexeddb/PageGroupIndexedDatabase.cpp:
		26	(WebCore::PageGroupIndexedDatabase::from):
		27	* Modules/indexeddb/WorkerGlobalScopeIndexedDatabase.cpp:
		28	(WebCore::WorkerGlobalScopeIndexedDatabase::from):
		29	* Modules/mediastream/UserMediaController.cpp:
		30	(WebCore::provideUserMediaTo):
		31	(WebCore::UserMediaController::create): Deleted.
		32	* Modules/mediastream/UserMediaController.h:
		33	* Modules/navigatorcontentutils/NavigatorContentUtils.cpp:
		34	(WebCore::provideNavigatorContentUtilsTo):
		35	(WebCore::NavigatorContentUtils::create): Deleted.
		36	* Modules/navigatorcontentutils/NavigatorContentUtils.h:
		37	* Modules/notifications/DOMWindowNotifications.cpp:
		38	(WebCore::DOMWindowNotifications::from):
		39	* Modules/notifications/NotificationController.cpp:
		40	(WebCore::provideNotification):
		41	(WebCore::NotificationController::create): Deleted.
		42	* Modules/notifications/NotificationController.h:
		43	* Modules/notifications/WorkerGlobalScopeNotifications.cpp:
		44	(WebCore::WorkerGlobalScopeNotifications::from):
		45	* Modules/proximity/DeviceProximityController.cpp:
		46	(WebCore::provideDeviceProximityTo):
		47	(WebCore::DeviceProximityController::create): Deleted.
		48	* Modules/proximity/DeviceProximityController.h:
		49	* Modules/quota/DOMWindowQuota.cpp:
		50	(WebCore::DOMWindowQuota::from):
		51	* Modules/quota/NavigatorStorageQuota.cpp:
		52	(WebCore::NavigatorStorageQuota::from):
		53	* Modules/quota/WorkerNavigatorStorageQuota.cpp:
		54	(WebCore::WorkerNavigatorStorageQuota::from):
		55	* Modules/speech/DOMWindowSpeechSynthesis.cpp:
		56	(WebCore::DOMWindowSpeechSynthesis::from):
		57	* Modules/speech/SpeechRecognitionController.cpp:
		58	(WebCore::provideSpeechRecognitionTo):
		59	* Modules/vibration/Vibration.cpp:
		60	(WebCore::provideVibrationTo):
		61	(WebCore::Vibration::create): Deleted.
		62	* Modules/vibration/Vibration.h:
		63	* dom/DeviceMotionController.cpp:
		64	(WebCore::provideDeviceMotionTo):
65	(WebCore::DeviceMotionController::create): Deleted.
66	* dom/DeviceMotionController.h:
67	* dom/DeviceOrientationController.cpp:
68	(WebCore::provideDeviceOrientationTo):
69	(WebCore::DeviceOrientationController::create): Deleted.
70	* dom/DeviceOrientationController.h:
71	* page/SpeechInput.cpp:
72	(WebCore::provideSpeechInputTo):
73	(WebCore::SpeechInput::create): Deleted.
74	* page/SpeechInput.h:
75	* platform/Supplementable.h:
76	(WebCore::Supplement::provideTo):
77	(WebCore::Supplementable::provideSupplement):
78	* testing/InternalSettings.cpp:
79	(WebCore::InternalSettings::from):
80
1	2014-04-30 Simon Fraser <simon.fraser@apple.com>	81	2014-04-30 Simon Fraser <simon.fraser@apple.com>
2		82
3	More iOS build fixing. MediaPlayerPrivateIOS is defunct and can be removed.	83	More iOS build fixing. MediaPlayerPrivateIOS is defunct and can be removed.

Lines 32-41 class BatteryClient; a/Source/WebCore/Modules/battery/BatteryController.h_sec1
- a/Source/WebCore/Modules/battery/BatteryController.h -4 / +1 lines
32		32
33	class BatteryController : public Supplement<Page> {	33	class BatteryController : public Supplement<Page> {
34	public:	34	public:
		35	explicit BatteryController(BatteryClient*);
35	~BatteryController();	36	~BatteryController();
36		37
37	static PassOwnPtr<BatteryController> create(BatteryClient*);
38
39	void addListener(BatteryManager*);	38	void addListener(BatteryManager*);
40	void removeListener(BatteryManager*);	39	void removeListener(BatteryManager*);
41	void updateBatteryStatus(PassRefPtr<BatteryStatus>);	40	void updateBatteryStatus(PassRefPtr<BatteryStatus>);
Lines 47-54 public: a/Source/WebCore/Modules/battery/BatteryController.h_sec2
47	private:	46	private:
48	typedef Vector<BatteryManager*> ListenerVector;	47	typedef Vector<BatteryManager*> ListenerVector;
49		48
50	explicit BatteryController(BatteryClient*);
51
52	BatteryClient* m_client;	49	BatteryClient* m_client;
53	ListenerVector m_listeners;	50	ListenerVector m_listeners;
54		51

Lines 31-43 class Navigator; a/Source/WebCore/Modules/battery/NavigatorBattery.h_sec1
- a/Source/WebCore/Modules/battery/NavigatorBattery.h -1 / +1 lines
31		31
32	class NavigatorBattery : public Supplement<Navigator> {	32	class NavigatorBattery : public Supplement<Navigator> {
33	public:	33	public:
		34	NavigatorBattery();
34	virtual ~NavigatorBattery();	35	virtual ~NavigatorBattery();
35		36
36	static NavigatorBattery* from(Navigator*);	37	static NavigatorBattery* from(Navigator*);
37	static BatteryManager* webkitBattery(Navigator*);	38	static BatteryManager* webkitBattery(Navigator*);
38		39
39	private:	40	private:
40	NavigatorBattery();
41	static const char* supplementName();	41	static const char* supplementName();
42		42
43	RefPtr<BatteryManager> m_batteryManager;	43	RefPtr<BatteryManager> m_batteryManager;

Lines 52-59 NavigatorGamepad* NavigatorGamepad::from(Navigator* navigator) a/Source/WebCore/Modules/gamepad/NavigatorGamepad.cpp_sec1
- a/Source/WebCore/Modules/gamepad/NavigatorGamepad.cpp -2 / +3 lines
52	{	52	{
53	NavigatorGamepad* supplement = static_cast<NavigatorGamepad*>(Supplement<Navigator>::from(navigator, supplementName()));	53	NavigatorGamepad* supplement = static_cast<NavigatorGamepad*>(Supplement<Navigator>::from(navigator, supplementName()));
54	if (!supplement) {	54	if (!supplement) {
55	supplement = new NavigatorGamepad();	55	auto newSupplement = std::make_unique<NavigatorGamepad>();
56	provideTo(navigator, supplementName(), adoptPtr(supplement));	56	supplement = newSupplement.get();
		57	provideTo(navigator, supplementName(), std::move(newSupplement));
57	}	58	}
58	return supplement;	59	return supplement;
59	}	60	}

Lines 37-43 class Navigator; a/Source/WebCore/Modules/gamepad/NavigatorGamepad.h_sec1
- a/Source/WebCore/Modules/gamepad/NavigatorGamepad.h -1 / +2 lines
37		37
38	class NavigatorGamepad : public Supplement<Navigator> {	38	class NavigatorGamepad : public Supplement<Navigator> {
39	public:	39	public:
		40	NavigatorGamepad();
40	virtual ~NavigatorGamepad();	41	virtual ~NavigatorGamepad();
		42
41	static NavigatorGamepad* from(Navigator*);	43	static NavigatorGamepad* from(Navigator*);
42		44
43	static GamepadList* webkitGetGamepads(Navigator*);	45	static GamepadList* webkitGetGamepads(Navigator*);
Lines 45-51 public: a/Source/WebCore/Modules/gamepad/NavigatorGamepad.h_sec2
45	GamepadList* gamepads();	47	GamepadList* gamepads();
46		48
47	private:	49	private:
48	NavigatorGamepad();
49	static const char* supplementName();	50	static const char* supplementName();
50		51
51	RefPtr<GamepadList> m_gamepads;	52	RefPtr<GamepadList> m_gamepads;

Lines 44-49 class Page; a/Source/WebCore/Modules/geolocation/GeolocationController.h_sec1
- a/Source/WebCore/Modules/geolocation/GeolocationController.h -2 / +1 lines
44	class GeolocationController : public Supplement<Page> {	44	class GeolocationController : public Supplement<Page> {
45	WTF_MAKE_NONCOPYABLE(GeolocationController);	45	WTF_MAKE_NONCOPYABLE(GeolocationController);
46	public:	46	public:
		47	explicit GeolocationController(GeolocationClient*);
47	~GeolocationController();	48	~GeolocationController();
48		49
49	static PassOwnPtr<GeolocationController> create(GeolocationClient*);	50	static PassOwnPtr<GeolocationController> create(GeolocationClient*);
Lines 65-72 public: a/Source/WebCore/Modules/geolocation/GeolocationController.h_sec2
65	static GeolocationController* from(Page* page) { return static_cast<GeolocationController*>(Supplement<Page>::from(page, supplementName())); }	66	static GeolocationController* from(Page* page) { return static_cast<GeolocationController*>(Supplement<Page>::from(page, supplementName())); }
66		67
67	private:	68	private:
68	GeolocationController(GeolocationClient*);
69
70	GeolocationClient* m_client;	69	GeolocationClient* m_client;
71		70
72	RefPtr<GeolocationPosition> m_lastPosition;	71	RefPtr<GeolocationPosition> m_lastPosition;

Lines 51-58 NavigatorGeolocation* NavigatorGeolocation::from(Navigator* navigator) a/Source/WebCore/Modules/geolocation/NavigatorGeolocation.cpp_sec1
- a/Source/WebCore/Modules/geolocation/NavigatorGeolocation.cpp -2 / +3 lines
51	{	51	{
52	NavigatorGeolocation* supplement = static_cast<NavigatorGeolocation*>(Supplement<Navigator>::from(navigator, supplementName()));	52	NavigatorGeolocation* supplement = static_cast<NavigatorGeolocation*>(Supplement<Navigator>::from(navigator, supplementName()));
53	if (!supplement) {	53	if (!supplement) {
54	supplement = new NavigatorGeolocation(navigator->frame());	54	auto newSupplement = std::make_unique<NavigatorGeolocation>(navigator->frame());
55	provideTo(navigator, supplementName(), adoptPtr(supplement));	55	supplement = newSupplement.get();
		56	provideTo(navigator, supplementName(), std::move(newSupplement));
56	}	57	}
57	return supplement;	58	return supplement;
58	}	59	}

Lines 33-38 class Navigator; a/Source/WebCore/Modules/geolocation/NavigatorGeolocation.h_sec1
- a/Source/WebCore/Modules/geolocation/NavigatorGeolocation.h -1 / +1 lines
33		33
34	class NavigatorGeolocation : public Supplement<Navigator>, public DOMWindowProperty {	34	class NavigatorGeolocation : public Supplement<Navigator>, public DOMWindowProperty {
35	public:	35	public:
		36	explicit NavigatorGeolocation(Frame*);
36	virtual ~NavigatorGeolocation();	37	virtual ~NavigatorGeolocation();
37	static NavigatorGeolocation* from(Navigator*);	38	static NavigatorGeolocation* from(Navigator*);
38		39
Lines 44-50 public: a/Source/WebCore/Modules/geolocation/NavigatorGeolocation.h_sec2
44	#endif // PLATFORM(IOS)	45	#endif // PLATFORM(IOS)
45		46
46	private:	47	private:
47	NavigatorGeolocation(Frame*);
48	static const char* supplementName();	48	static const char* supplementName();
49		49
50	mutable RefPtr<Geolocation> m_geolocation;	50	mutable RefPtr<Geolocation> m_geolocation;

Lines 38-44 class DOMWindow; a/Source/WebCore/Modules/indexeddb/DOMWindowIndexedDatabase.h_sec1
- a/Source/WebCore/Modules/indexeddb/DOMWindowIndexedDatabase.h -2 / +2 lines
38		38
39	class DOMWindowIndexedDatabase : public DOMWindowProperty, public Supplement<DOMWindow> {	39	class DOMWindowIndexedDatabase : public DOMWindowProperty, public Supplement<DOMWindow> {
40	public:	40	public:
		41	explicit DOMWindowIndexedDatabase(DOMWindow*);
41	virtual ~DOMWindowIndexedDatabase();	42	virtual ~DOMWindowIndexedDatabase();
		43
42	static DOMWindowIndexedDatabase* from(DOMWindow*);	44	static DOMWindowIndexedDatabase* from(DOMWindow*);
43		45
44	static IDBFactory* indexedDB(DOMWindow*);	46	static IDBFactory* indexedDB(DOMWindow*);
Lines 50-57 public: a/Source/WebCore/Modules/indexeddb/DOMWindowIndexedDatabase.h_sec2
50	virtual void willDetachGlobalObjectFromFrame() override;	52	virtual void willDetachGlobalObjectFromFrame() override;
51		53
52	private:	54	private:
53	explicit DOMWindowIndexedDatabase(DOMWindow*);
54
55	IDBFactory* indexedDB();	55	IDBFactory* indexedDB();
56	static const char* supplementName();	56	static const char* supplementName();
57		57

Lines 52-59 PageGroupIndexedDatabase* PageGroupIndexedDatabase::from(PageGroup& group) a/Source/WebCore/Modules/indexeddb/PageGroupIndexedDatabase.cpp_sec1
- a/Source/WebCore/Modules/indexeddb/PageGroupIndexedDatabase.cpp -2 / +3 lines
52	{	52	{
53	PageGroupIndexedDatabase* supplement = static_cast<PageGroupIndexedDatabase*>(Supplement<PageGroup>::from(&group, supplementName()));	53	PageGroupIndexedDatabase* supplement = static_cast<PageGroupIndexedDatabase*>(Supplement<PageGroup>::from(&group, supplementName()));
54	if (!supplement) {	54	if (!supplement) {
55	supplement = new PageGroupIndexedDatabase(group.groupSettings().indexedDBDatabasePath());	55	auto newSupplement = std::make_unique<PageGroupIndexedDatabase>(group.groupSettings().indexedDBDatabasePath());
56	provideTo(&group, supplementName(), adoptPtr(supplement));	56	supplement = newSupplement.get();
		57	provideTo(&group, supplementName(), std::move(newSupplement));
57	}	58	}
58	return supplement;	59	return supplement;
59	}	60	}

Lines 38-50 class PageGroup; a/Source/WebCore/Modules/indexeddb/PageGroupIndexedDatabase.h_sec1
- a/Source/WebCore/Modules/indexeddb/PageGroupIndexedDatabase.h -1 / +2 lines
38		38
39	class PageGroupIndexedDatabase : public Supplement<PageGroup> {	39	class PageGroupIndexedDatabase : public Supplement<PageGroup> {
40	public:	40	public:
		41	explicit PageGroupIndexedDatabase(const String& databaseDirectoryIdentifier);
41	virtual ~PageGroupIndexedDatabase();	42	virtual ~PageGroupIndexedDatabase();
		43
42	static PageGroupIndexedDatabase* from(PageGroup&);	44	static PageGroupIndexedDatabase* from(PageGroup&);
43		45
44	IDBFactoryBackendInterface* factoryBackend();	46	IDBFactoryBackendInterface* factoryBackend();
45		47
46	private:	48	private:
47	explicit PageGroupIndexedDatabase(const String& databaseDirectoryIdentifier);
48	static const char* supplementName();	49	static const char* supplementName();
49		50
50	String m_databaseDirectoryIdentifier;	51	String m_databaseDirectoryIdentifier;

Lines 40-53 class ScriptExecutionContext; a/Source/WebCore/Modules/indexeddb/WorkerGlobalScopeIndexedDatabase.h_sec1
- a/Source/WebCore/Modules/indexeddb/WorkerGlobalScopeIndexedDatabase.h -2 / +1 lines
40		40
41	class WorkerGlobalScopeIndexedDatabase : public Supplement<ScriptExecutionContext> {	41	class WorkerGlobalScopeIndexedDatabase : public Supplement<ScriptExecutionContext> {
42	public:	42	public:
		43	explicit WorkerGlobalScopeIndexedDatabase(const String& databaseDirectoryIdentifier);
43	virtual ~WorkerGlobalScopeIndexedDatabase();	44	virtual ~WorkerGlobalScopeIndexedDatabase();
44	static WorkerGlobalScopeIndexedDatabase* from(ScriptExecutionContext*);	45	static WorkerGlobalScopeIndexedDatabase* from(ScriptExecutionContext*);
45		46
46	static IDBFactory* indexedDB(ScriptExecutionContext*);	47	static IDBFactory* indexedDB(ScriptExecutionContext*);
47		48
48	private:	49	private:
49	explicit WorkerGlobalScopeIndexedDatabase(const String& databaseDirectoryIdentifier);
50
51	IDBFactory* indexedDB();	50	IDBFactory* indexedDB();
52	static const char* supplementName();	51	static const char* supplementName();
53		52

Lines 44-58 UserMediaController::~UserMediaController() a/Source/WebCore/Modules/mediastream/UserMediaController.cpp_sec1
- a/Source/WebCore/Modules/mediastream/UserMediaController.cpp -6 / +1 lines
44	m_client->pageDestroyed();	44	m_client->pageDestroyed();
45	}	45	}
46		46
47	PassOwnPtr<UserMediaController> UserMediaController::create(UserMediaClient* client)
48	{
49	return adoptPtr(new UserMediaController(client));
50	}
51
52	void provideUserMediaTo(Page* page, UserMediaClient* client)	47	void provideUserMediaTo(Page* page, UserMediaClient* client)
53	{	48	{
54	if (!Supplement<Page>::from(page, UserMediaController::supplementName()))	49	if (!Supplement<Page>::from(page, UserMediaController::supplementName()))
55	UserMediaController::provideTo(page, UserMediaController::supplementName(), UserMediaController::create(client));	50	UserMediaController::provideTo(page, UserMediaController::supplementName(), std::make_unique<UserMediaController>(client));
56	}	51	}
57		52
58	} // namespace WebCore	53	} // namespace WebCore

Lines 36-54 namespace WebCore { a/Source/WebCore/Modules/mediastream/UserMediaController.h_sec1
- a/Source/WebCore/Modules/mediastream/UserMediaController.h -4 / +1 lines
36		36
37	class UserMediaController : public Supplement<Page> {	37	class UserMediaController : public Supplement<Page> {
38	public:	38	public:
		39	explicit UserMediaController(UserMediaClient*);
39	~UserMediaController();	40	~UserMediaController();
40		41
41	UserMediaClient* client() const { return m_client; }	42	UserMediaClient* client() const { return m_client; }
42	void requestPermission(PassRefPtr<UserMediaRequest>);	43	void requestPermission(PassRefPtr<UserMediaRequest>);
43	void cancelRequest(UserMediaRequest*);	44	void cancelRequest(UserMediaRequest*);
44		45
45	static PassOwnPtr<UserMediaController> create(UserMediaClient*);
46	static const char* supplementName();	46	static const char* supplementName();
47	static UserMediaController* from(Page* page) { return static_cast<UserMediaController*>(Supplement<Page>::from(page, supplementName())); }	47	static UserMediaController* from(Page* page) { return static_cast<UserMediaController*>(Supplement<Page>::from(page, supplementName())); }
48		48
49	protected:
50	explicit UserMediaController(UserMediaClient*);
51
52	private:	49	private:
53	UserMediaClient* m_client;	50	UserMediaClient* m_client;
54	};	51	};

Lines 43-48 typedef int ExceptionCode; a/Source/WebCore/Modules/navigatorcontentutils/NavigatorContentUtils.h_sec1
- a/Source/WebCore/Modules/navigatorcontentutils/NavigatorContentUtils.h -6 / +4 lines
43		43
44	class NavigatorContentUtils final : public Supplement<Page> {	44	class NavigatorContentUtils final : public Supplement<Page> {
45	public:	45	public:
		46	explicit NavigatorContentUtils(std::unique_ptr<NavigatorContentUtilsClient> client)
		47	: m_client(std::move(client))
		48	{ }
		49
46	virtual ~NavigatorContentUtils();	50	virtual ~NavigatorContentUtils();
47		51
48	static const char* supplementName();	52	static const char* supplementName();
Lines 55-67 public: a/Source/WebCore/Modules/navigatorcontentutils/NavigatorContentUtils.h_sec2
55	static void unregisterProtocolHandler(Navigator*, const String& scheme, const String& url, ExceptionCode&);	59	static void unregisterProtocolHandler(Navigator*, const String& scheme, const String& url, ExceptionCode&);
56	#endif	60	#endif
57		61
58	static PassOwnPtr<NavigatorContentUtils> create(std::unique_ptr<NavigatorContentUtilsClient>);
59
60	private:	62	private:
61	explicit NavigatorContentUtils(std::unique_ptr<NavigatorContentUtilsClient> client)
62	: m_client(std::move(client))
63	{ }
64
65	NavigatorContentUtilsClient* client() { return m_client.get(); }	63	NavigatorContentUtilsClient* client() { return m_client.get(); }
66		64
67	std::unique_ptr<NavigatorContentUtilsClient> m_client;	65	std::unique_ptr<NavigatorContentUtilsClient> m_client;

Lines 56-63 DOMWindowNotifications* DOMWindowNotifications::from(DOMWindow* window) a/Source/WebCore/Modules/notifications/DOMWindowNotifications.cpp_sec1
- a/Source/WebCore/Modules/notifications/DOMWindowNotifications.cpp -2 / +3 lines
56	{	56	{
57	DOMWindowNotifications* supplement = static_cast<DOMWindowNotifications*>(Supplement<DOMWindow>::from(window, supplementName()));	57	DOMWindowNotifications* supplement = static_cast<DOMWindowNotifications*>(Supplement<DOMWindow>::from(window, supplementName()));
58	if (!supplement) {	58	if (!supplement) {
59	supplement = new DOMWindowNotifications(window);	59	auto newSupplement = std::make_unique<DOMWindowNotifications>(window);
60	Supplement<DOMWindow>::provideTo(window, supplementName(), adoptPtr(supplement));	60	supplement = newSupplement.get();
		61	provideTo(window, supplementName(), std::move(newSupplement));
61	}	62	}
62	return supplement;	63	return supplement;
63	}	64	}

Lines 40-45 class NotificationCenter; a/Source/WebCore/Modules/notifications/DOMWindowNotifications.h_sec1
- a/Source/WebCore/Modules/notifications/DOMWindowNotifications.h -2 / +1 lines
40		40
41	class DOMWindowNotifications : public Supplement<DOMWindow>, public DOMWindowProperty {	41	class DOMWindowNotifications : public Supplement<DOMWindow>, public DOMWindowProperty {
42	public:	42	public:
		43	explicit DOMWindowNotifications(DOMWindow*);
43	virtual ~DOMWindowNotifications();	44	virtual ~DOMWindowNotifications();
44		45
45	static NotificationCenter* webkitNotifications(DOMWindow*);	46	static NotificationCenter* webkitNotifications(DOMWindow*);
Lines 52-59 public: a/Source/WebCore/Modules/notifications/DOMWindowNotifications.h_sec2
52	virtual void willDetachGlobalObjectFromFrame() override;	53	virtual void willDetachGlobalObjectFromFrame() override;
53		54
54	private:	55	private:
55	explicit DOMWindowNotifications(DOMWindow*);
56
57	NotificationCenter* webkitNotifications();	56	NotificationCenter* webkitNotifications();
58	static const char* supplementName();	57	static const char* supplementName();
59		58

Lines 44-54 NotificationController::~NotificationController() a/Source/WebCore/Modules/notifications/NotificationController.cpp_sec1
- a/Source/WebCore/Modules/notifications/NotificationController.cpp -6 / +1 lines
44	m_client->notificationControllerDestroyed();	44	m_client->notificationControllerDestroyed();
45	}	45	}
46		46
47	PassOwnPtr<NotificationController> NotificationController::create(NotificationClient* client)
48	{
49	return adoptPtr(new NotificationController(client));
50	}
51
52	NotificationClient* NotificationController::clientFrom(Page* page)	47	NotificationClient* NotificationController::clientFrom(Page* page)
53	{	48	{
54	if (NotificationController* controller = NotificationController::from(page))	49	if (NotificationController* controller = NotificationController::from(page))
Lines 63-69 const char* NotificationController::supplementName() a/Source/WebCore/Modules/notifications/NotificationController.cpp_sec2
63		58
64	void provideNotification(Page* page, NotificationClient* client)	59	void provideNotification(Page* page, NotificationClient* client)
65	{	60	{
66	NotificationController::provideTo(page, NotificationController::supplementName(), NotificationController::create(client));	61	NotificationController::provideTo(page, NotificationController::supplementName(), std::make_unique<NotificationController>(client));
67	}	62	}
68		63
69	} // namespace WebCore	64	} // namespace WebCore

Lines 39-47 class NotificationClient; a/Source/WebCore/Modules/notifications/NotificationController.h_sec1
- a/Source/WebCore/Modules/notifications/NotificationController.h -3 / +1 lines
39	class NotificationController : public Supplement<Page> {	39	class NotificationController : public Supplement<Page> {
40	WTF_MAKE_NONCOPYABLE(NotificationController);	40	WTF_MAKE_NONCOPYABLE(NotificationController);
41	public:	41	public:
		42	explicit NotificationController(NotificationClient*);
42	~NotificationController();	43	~NotificationController();
43		44
44	static PassOwnPtr<NotificationController> create(NotificationClient*);
45	static const char* supplementName();	45	static const char* supplementName();
46	static NotificationController* from(Page* page) { return static_cast<NotificationController*>(Supplement<Page>::from(page, supplementName())); }	46	static NotificationController* from(Page* page) { return static_cast<NotificationController*>(Supplement<Page>::from(page, supplementName())); }
47	static NotificationClient* clientFrom(Page*);	47	static NotificationClient* clientFrom(Page*);
Lines 49-56 public: a/Source/WebCore/Modules/notifications/NotificationController.h_sec2
49	NotificationClient* client() { return m_client; }	49	NotificationClient* client() { return m_client; }
50		50
51	private:	51	private:
52	explicit NotificationController(NotificationClient*);
53
54	NotificationClient* m_client;	52	NotificationClient* m_client;
55	};	53	};
56		54

Lines 54-61 WorkerGlobalScopeNotifications* WorkerGlobalScopeNotifications::from(WorkerGloba a/Source/WebCore/Modules/notifications/WorkerGlobalScopeNotifications.cpp_sec1
- a/Source/WebCore/Modules/notifications/WorkerGlobalScopeNotifications.cpp -2 / +3 lines
54	{	54	{
55	WorkerGlobalScopeNotifications* supplement = static_cast<WorkerGlobalScopeNotifications*>(Supplement<ScriptExecutionContext>::from(context, supplementName()));	55	WorkerGlobalScopeNotifications* supplement = static_cast<WorkerGlobalScopeNotifications*>(Supplement<ScriptExecutionContext>::from(context, supplementName()));
56	if (!supplement) {	56	if (!supplement) {
57	supplement = new WorkerGlobalScopeNotifications(context);	57	auto newSupplement = std::make_unique<WorkerGlobalScopeNotifications>(context);
58	Supplement<ScriptExecutionContext>::provideTo(context, supplementName(), adoptPtr(supplement));	58	supplement = newSupplement.get();
		59	provideTo(context, supplementName(), std::move(newSupplement));
59	}	60	}
60	return supplement;	61	return supplement;
61	}	62	}

Lines 39-52 class WorkerGlobalScope; a/Source/WebCore/Modules/notifications/WorkerGlobalScopeNotifications.h_sec1
- a/Source/WebCore/Modules/notifications/WorkerGlobalScopeNotifications.h -2 / +1 lines
39		39
40	class WorkerGlobalScopeNotifications : public Supplement<ScriptExecutionContext> {	40	class WorkerGlobalScopeNotifications : public Supplement<ScriptExecutionContext> {
41	public:	41	public:
		42	explicit WorkerGlobalScopeNotifications(WorkerGlobalScope*);
42	virtual ~WorkerGlobalScopeNotifications();	43	virtual ~WorkerGlobalScopeNotifications();
43		44
44	static NotificationCenter* webkitNotifications(WorkerGlobalScope*);	45	static NotificationCenter* webkitNotifications(WorkerGlobalScope*);
45	static WorkerGlobalScopeNotifications* from(WorkerGlobalScope*);	46	static WorkerGlobalScopeNotifications* from(WorkerGlobalScope*);
46		47
47	private:	48	private:
48	explicit WorkerGlobalScopeNotifications(WorkerGlobalScope*);
49
50	NotificationCenter* webkitNotifications();	49	NotificationCenter* webkitNotifications();
51	static const char* supplementName();	50	static const char* supplementName();
52		51

Lines 40-50 DeviceProximityController::DeviceProximityController(DeviceProximityClient* clie a/Source/WebCore/Modules/proximity/DeviceProximityController.cpp_sec1
- a/Source/WebCore/Modules/proximity/DeviceProximityController.cpp -6 / +1 lines
40	ASSERT(m_client);	40	ASSERT(m_client);
41	}	41	}
42		42
43	PassOwnPtr<DeviceProximityController> DeviceProximityController::create(DeviceProximityClient* client)
44	{
45	return adoptPtr(new DeviceProximityController(client));
46	}
47
48	void DeviceProximityController::didChangeDeviceProximity(const double value, const double min, const double max)	43	void DeviceProximityController::didChangeDeviceProximity(const double value, const double min, const double max)
49	{	44	{
50	ASSERT(value >= min && value <= max);	45	ASSERT(value >= min && value <= max);
Lines 86-92 bool DeviceProximityController::isActiveAt(Page* page) a/Source/WebCore/Modules/proximity/DeviceProximityController.cpp_sec2
86		81
87	void provideDeviceProximityTo(Page* page, DeviceProximityClient* client)	82	void provideDeviceProximityTo(Page* page, DeviceProximityClient* client)
88	{	83	{
89	DeviceProximityController::provideTo(page, DeviceProximityController::supplementName(), DeviceProximityController::create(client));	84	DeviceProximityController::provideTo(page, DeviceProximityController::supplementName(), std::make_unique<DeviceProximityController>(client));
90	}	85	}
91		86
92	} // namespace WebCore	87	} // namespace WebCore

Lines 36-45 class DeviceProximityClient; a/Source/WebCore/Modules/proximity/DeviceProximityController.h_sec1
- a/Source/WebCore/Modules/proximity/DeviceProximityController.h -5 / +1 lines
36		36
37	class DeviceProximityController : public DeviceController {	37	class DeviceProximityController : public DeviceController {
38	public:	38	public:
		39	explicit DeviceProximityController(DeviceProximityClient*);
39	~DeviceProximityController() { }	40	~DeviceProximityController() { }
40		41
41	static PassOwnPtr<DeviceProximityController> create(DeviceProximityClient*);
42
43	void didChangeDeviceProximity(const double value, const double min, const double max);	42	void didChangeDeviceProximity(const double value, const double min, const double max);
44	DeviceProximityClient* deviceProximityClient();	43	DeviceProximityClient* deviceProximityClient();
45		44
Lines 49-57 public: a/Source/WebCore/Modules/proximity/DeviceProximityController.h_sec2
49	static const char* supplementName();	48	static const char* supplementName();
50	static DeviceProximityController* from(Page*);	49	static DeviceProximityController* from(Page*);
51	static bool isActiveAt(Page*);	50	static bool isActiveAt(Page*);
52
53	private:
54	explicit DeviceProximityController(DeviceProximityClient*);
55	};	51	};
56		52
57	} // namespace WebCore	53	} // namespace WebCore

Lines 60-67 DOMWindowQuota* DOMWindowQuota::from(DOMWindow* window) a/Source/WebCore/Modules/quota/DOMWindowQuota.cpp_sec1
- a/Source/WebCore/Modules/quota/DOMWindowQuota.cpp -2 / +3 lines
60	{	60	{
61	DOMWindowQuota* supplement = static_cast<DOMWindowQuota*>(Supplement<DOMWindow>::from(window, supplementName()));	61	DOMWindowQuota* supplement = static_cast<DOMWindowQuota*>(Supplement<DOMWindow>::from(window, supplementName()));
62	if (!supplement) {	62	if (!supplement) {
63	supplement = new DOMWindowQuota(window);	63	auto newSupplement = std::make_unique<DOMWindowQuota>(window);
64	provideTo(window, supplementName(), adoptPtr(supplement));	64	supplement = newSupplement.get();
		65	provideTo(window, supplementName(), std::move(newSupplement));
65	}	66	}
66	return supplement;	67	return supplement;
67	}	68	}

Lines 43-55 class StorageInfo; a/Source/WebCore/Modules/quota/DOMWindowQuota.h_sec1
- a/Source/WebCore/Modules/quota/DOMWindowQuota.h -1 / +1 lines
43		43
44	class DOMWindowQuota : public Supplement<DOMWindow>, public DOMWindowProperty {	44	class DOMWindowQuota : public Supplement<DOMWindow>, public DOMWindowProperty {
45	public:	45	public:
		46	explicit DOMWindowQuota(DOMWindow*);
46	virtual ~DOMWindowQuota();	47	virtual ~DOMWindowQuota();
47	static DOMWindowQuota* from(DOMWindow*);	48	static DOMWindowQuota* from(DOMWindow*);
48	static StorageInfo* webkitStorageInfo(DOMWindow*);	49	static StorageInfo* webkitStorageInfo(DOMWindow*);
49	StorageInfo* webkitStorageInfo() const;	50	StorageInfo* webkitStorageInfo() const;
50		51
51	private:	52	private:
52	explicit DOMWindowQuota(DOMWindow*);
53	static const char* supplementName();	53	static const char* supplementName();
54		54
55	mutable RefPtr<StorageInfo> m_storageInfo;	55	mutable RefPtr<StorageInfo> m_storageInfo;

Lines 57-64 NavigatorStorageQuota* NavigatorStorageQuota::from(Navigator* navigator) a/Source/WebCore/Modules/quota/NavigatorStorageQuota.cpp_sec1
- a/Source/WebCore/Modules/quota/NavigatorStorageQuota.cpp -2 / +3 lines
57	{	57	{
58	NavigatorStorageQuota* supplement = static_cast<NavigatorStorageQuota*>(Supplement<Navigator>::from(navigator, supplementName()));	58	NavigatorStorageQuota* supplement = static_cast<NavigatorStorageQuota*>(Supplement<Navigator>::from(navigator, supplementName()));
59	if (!supplement) {	59	if (!supplement) {
60	supplement = new NavigatorStorageQuota(navigator->frame());	60	auto newSupplement = std::make_unique<NavigatorStorageQuota>(window);
61	provideTo(navigator, supplementName(), adoptPtr(supplement));	61	supplement = newSupplement.get();
		62	provideTo(navigator, supplementName(), std::move(newSupplement));
62	}	63	}
63	return supplement;	64	return supplement;
64	}	65	}

Lines 44-49 class Navigator; a/Source/WebCore/Modules/quota/NavigatorStorageQuota.h_sec1
- a/Source/WebCore/Modules/quota/NavigatorStorageQuota.h -1 / +1 lines
44		44
45	class NavigatorStorageQuota : public Supplement<Navigator>, public DOMWindowProperty {	45	class NavigatorStorageQuota : public Supplement<Navigator>, public DOMWindowProperty {
46	public:	46	public:
		47	explicit NavigatorStorageQuota(Frame*);
47	virtual ~NavigatorStorageQuota();	48	virtual ~NavigatorStorageQuota();
48	static NavigatorStorageQuota* from(Navigator*);	49	static NavigatorStorageQuota* from(Navigator*);
49		50
Lines 53-59 public: a/Source/WebCore/Modules/quota/NavigatorStorageQuota.h_sec2
53	StorageQuota* webkitPersistentStorage() const;	54	StorageQuota* webkitPersistentStorage() const;
54		55
55	private:	56	private:
56	explicit NavigatorStorageQuota(Frame*);
57	static const char* supplementName();	57	static const char* supplementName();
58		58
59	mutable RefPtr<StorageQuota> m_temporaryStorage;	59	mutable RefPtr<StorageQuota> m_temporaryStorage;

Lines 55-62 WorkerNavigatorStorageQuota* WorkerNavigatorStorageQuota::from(WorkerNavigator* a/Source/WebCore/Modules/quota/WorkerNavigatorStorageQuota.cpp_sec1
- a/Source/WebCore/Modules/quota/WorkerNavigatorStorageQuota.cpp -2 / +3 lines
55	{	55	{
56	WorkerNavigatorStorageQuota* supplement = static_cast<WorkerNavigatorStorageQuota*>(Supplement<WorkerNavigator>::from(navigator, supplementName()));	56	WorkerNavigatorStorageQuota* supplement = static_cast<WorkerNavigatorStorageQuota*>(Supplement<WorkerNavigator>::from(navigator, supplementName()));
57	if (!supplement) {	57	if (!supplement) {
58	supplement = new WorkerNavigatorStorageQuota();	58	auto newSupplement = std::make_unique<WorkerNavigatorStorageQuota>(window);
59	provideTo(navigator, supplementName(), adoptPtr(supplement));	59	supplement = newSupplement.get();
		60	provideTo(navigator, supplementName(), std::move(newSupplement));
60	}	61	}
61	return supplement;	62	return supplement;
62	}	63	}

Lines 44-49 class WorkerNavigator; a/Source/WebCore/Modules/quota/WorkerNavigatorStorageQuota.h_sec1
- a/Source/WebCore/Modules/quota/WorkerNavigatorStorageQuota.h -1 / +1 lines
44		44
45	class WorkerNavigatorStorageQuota : public Supplement<WorkerNavigator> {	45	class WorkerNavigatorStorageQuota : public Supplement<WorkerNavigator> {
46	public:	46	public:
		47	explicit WorkerNavigatorStorageQuota();
47	virtual ~WorkerNavigatorStorageQuota();	48	virtual ~WorkerNavigatorStorageQuota();
48	static WorkerNavigatorStorageQuota* from(WorkerNavigator*);	49	static WorkerNavigatorStorageQuota* from(WorkerNavigator*);
49		50
Lines 53-59 public: a/Source/WebCore/Modules/quota/WorkerNavigatorStorageQuota.h_sec2
53	StorageQuota* webkitPersistentStorage() const;	54	StorageQuota* webkitPersistentStorage() const;
54		55
55	private:	56	private:
56	explicit WorkerNavigatorStorageQuota();
57	static const char* supplementName();	57	static const char* supplementName();
58		58
59	mutable RefPtr<StorageQuota> m_temporaryStorage;	59	mutable RefPtr<StorageQuota> m_temporaryStorage;

Lines 57-64 DOMWindowSpeechSynthesis* DOMWindowSpeechSynthesis::from(DOMWindow* window) a/Source/WebCore/Modules/speech/DOMWindowSpeechSynthesis.cpp_sec1
- a/Source/WebCore/Modules/speech/DOMWindowSpeechSynthesis.cpp -2 / +3 lines
57	{	57	{
58	DOMWindowSpeechSynthesis* supplement = static_cast<DOMWindowSpeechSynthesis*>(Supplement<DOMWindow>::from(window, supplementName()));	58	DOMWindowSpeechSynthesis* supplement = static_cast<DOMWindowSpeechSynthesis*>(Supplement<DOMWindow>::from(window, supplementName()));
59	if (!supplement) {	59	if (!supplement) {
60	supplement = new DOMWindowSpeechSynthesis(window);	60	auto newSupplement = std::make_unique<DOMWindowSpeechSynthesis>(window);
61	provideTo(window, supplementName(), adoptPtr(supplement));	61	supplement = newSupplement.get();
		62	provideTo(window, supplementName(), std::move(newSupplement));
62	}	63	}
63	return supplement;	64	return supplement;
64	}	65	}