Changeset 204524 in webkit


Ignore:
Timestamp:
Aug 16, 2016 2:44:25 PM (8 years ago)
Author:
beidson@apple.com
Message:

Cleanup WK2 platform gamepad handling.
​https://bugs.webkit.org/show_bug.cgi?id=160871

Reviewed by Alex Christensen.

Source/WebCore:

No new tests (No currently testable change in behavior).

This patch does a few things:
1 - Separates the concepts of "monitoring gamepads" and "monitoring gamepad inputs"
2 - Uses this new concept to much more cleanly handle the case where we are not currently

monitoring gamepad inputs because an interested WKWebView is not front and center.

3 - Pre-populates the "initial set of gamepads" in WebProcesses that start listening for gamepads.

  • platform/gamepad/GamepadProviderClient.h:

(WebCore::GamepadProviderClient::setInitialConnectedGamepads):

  • platform/gamepad/mac/HIDGamepadProvider.cpp:

(WebCore::HIDGamepadProvider::HIDGamepadProvider):
(WebCore::HIDGamepadProvider::stopMonitoringInput):
(WebCore::HIDGamepadProvider::startMonitoringInput):
(WebCore::HIDGamepadProvider::connectionDelayTimerFired):

  • platform/gamepad/mac/HIDGamepadProvider.h:

Source/WebKit2:

This patch does a few things:
1 - Separates the concepts of "monitoring gamepads" and "monitoring gamepad inputs"
2 - Uses this new concept to much more cleanly handle the case where we are not currently

monitoring gamepad inputs because an interested WKWebView is not front and center.

3 - Pre-populates the "initial set of gamepads" in WebProcesses that start listening for gamepads.

  • Platform/Logging.h:
  • UIProcess/Gamepad/UIGamepadProvider.cpp:

(WebKit::UIGamepadProvider::gamepadSyncTimerFired):
(WebKit::UIGamepadProvider::setInitialConnectedGamepads):
(WebKit::UIGamepadProvider::processPoolStoppedUsingGamepads):
(WebKit::UIGamepadProvider::viewBecameActive):
(WebKit::UIGamepadProvider::viewBecameInactive):
(WebKit::UIGamepadProvider::stopMonitoringGamepads):
(WebKit::UIGamepadProvider::snapshotGamepads):
(WebKit::UIGamepadProvider::platformStopMonitoringInput):
(WebKit::UIGamepadProvider::platformStartMonitoringInput):
(WebKit::UIGamepadProvider::UIGamepadProvider): Deleted.
(WebKit::UIGamepadProvider::scheduleDisableGamepadMonitoring): Deleted.
(WebKit::UIGamepadProvider::disableMonitoringTimerFired): Deleted.

  • UIProcess/Gamepad/UIGamepadProvider.h:
  • UIProcess/Gamepad/mac/UIGamepadProviderHID.cpp:

(WebKit::UIGamepadProvider::platformStopMonitoringInput):
(WebKit::UIGamepadProvider::platformStartMonitoringInput):

  • UIProcess/WebProcessPool.cpp:

(WebKit::WebProcessPool::setInitialConnectedGamepads):

  • UIProcess/WebProcessPool.h:
  • WebProcess/Gamepad/WebGamepadProvider.cpp:

(WebKit::WebGamepadProvider::setInitialGamepads):

  • WebProcess/Gamepad/WebGamepadProvider.h:
  • WebProcess/WebProcess.cpp:

(WebKit::WebProcess::setInitialGamepads):

  • WebProcess/WebProcess.h:
  • WebProcess/WebProcess.messages.in:
Location:
trunk/Source
Files:
16 edited

Legend:

Unmodified
Added
Removed

  • trunk/Source/WebCore/ChangeLog

    r204522 r204524  
     12016-08-16  Brady Eidson  <beidson@apple.com>
     2
     3        Cleanup WK2 platform gamepad handling.
     4        https://bugs.webkit.org/show_bug.cgi?id=160871
     5
     6        Reviewed by Alex Christensen.
     7
     8        No new tests (No currently testable change in behavior).
     9
     10        This patch does a few things:
     11        1 - Separates the concepts of "monitoring gamepads" and "monitoring gamepad inputs"
     12        2 - Uses this new concept to much more cleanly handle the case where we are not currently
     13            monitoring gamepad inputs because an interested WKWebView is not front and center.
     14        3 - Pre-populates the "initial set of gamepads" in WebProcesses that start listening for gamepads.
     15
     16        * platform/gamepad/GamepadProviderClient.h:
     17        (WebCore::GamepadProviderClient::setInitialConnectedGamepads):
     18
     19        * platform/gamepad/mac/HIDGamepadProvider.cpp:
     20        (WebCore::HIDGamepadProvider::HIDGamepadProvider):
     21        (WebCore::HIDGamepadProvider::stopMonitoringInput):
     22        (WebCore::HIDGamepadProvider::startMonitoringInput):
     23        (WebCore::HIDGamepadProvider::connectionDelayTimerFired):
     24        * platform/gamepad/mac/HIDGamepadProvider.h:
     25
    1262016-08-16  Chris Dumez  <cdumez@apple.com>
    227

  • trunk/Source/WebCore/platform/gamepad/GamepadProviderClient.h

    r204509 r204524  
    2828#if ENABLE(GAMEPAD)
    2929
     30#include <wtf/Vector.h>
     31
    3032namespace WebCore {
    3133
    … …  
    3638    virtual ~GamepadProviderClient() { }
    3739
     40    virtual void setInitialConnectedGamepads(const Vector<PlatformGamepad*>&) { }
    3841    virtual void platformGamepadConnected(PlatformGamepad&) = 0;
    3942    virtual void platformGamepadDisconnected(PlatformGamepad&) = 0;

  • trunk/Source/WebCore/platform/gamepad/mac/HIDGamepadProvider.cpp

    r204509 r204524  
    9797    IOHIDManagerRegisterDeviceMatchingCallback(m_manager.get(), deviceAddedCallback, this);
    9898    IOHIDManagerRegisterDeviceRemovalCallback(m_manager.get(), deviceRemovedCallback, this);
     99
     100    startMonitoringInput();
     101}
     102
     103void HIDGamepadProvider::stopMonitoringInput()
     104{
     105#pragma clang diagnostic push
     106#pragma clang diagnostic ignored "-Wnonnull"
     107    IOHIDManagerRegisterInputValueCallback(m_manager.get(), nullptr, nullptr);
     108#pragma clang diagnostic pop
     109}
     110
     111void HIDGamepadProvider::startMonitoringInput()
     112{
    99113    IOHIDManagerRegisterInputValueCallback(m_manager.get(), deviceValuesChangedCallback, this);
    100114}
    … …  
    112126{
    113127    m_shouldDispatchCallbacks = true;
     128
     129    for (auto* client : m_clients)
     130        client->setInitialConnectedGamepads(m_gamepadVector);
    114131}
    115132

  • trunk/Source/WebCore/platform/gamepad/mac/HIDGamepadProvider.h

    r204509 r204524  
    5252    const Vector<PlatformGamepad*>& platformGamepads() final { return m_gamepadVector; }
    5353
     54    WEBCORE_EXPORT void stopMonitoringInput();
     55    WEBCORE_EXPORT void startMonitoringInput();
     56   
    5457    void deviceAdded(IOHIDDeviceRef);
    5558    void deviceRemoved(IOHIDDeviceRef);

  • trunk/Source/WebKit2/ChangeLog

    r204523 r204524  
     12016-08-16  Brady Eidson  <beidson@apple.com>
     2
     3        Cleanup WK2 platform gamepad handling.
     4        https://bugs.webkit.org/show_bug.cgi?id=160871
     5
     6        Reviewed by Alex Christensen.
     7
     8        This patch does a few things:
     9        1 - Separates the concepts of "monitoring gamepads" and "monitoring gamepad inputs"
     10        2 - Uses this new concept to much more cleanly handle the case where we are not currently
     11            monitoring gamepad inputs because an interested WKWebView is not front and center.
     12        3 - Pre-populates the "initial set of gamepads" in WebProcesses that start listening for gamepads.
     13       
     14        * Platform/Logging.h:
     15       
     16        * UIProcess/Gamepad/UIGamepadProvider.cpp:
     17        (WebKit::UIGamepadProvider::gamepadSyncTimerFired):
     18        (WebKit::UIGamepadProvider::setInitialConnectedGamepads):
     19        (WebKit::UIGamepadProvider::processPoolStoppedUsingGamepads):
     20        (WebKit::UIGamepadProvider::viewBecameActive):
     21        (WebKit::UIGamepadProvider::viewBecameInactive):
     22        (WebKit::UIGamepadProvider::stopMonitoringGamepads):
     23        (WebKit::UIGamepadProvider::snapshotGamepads):
     24        (WebKit::UIGamepadProvider::platformStopMonitoringInput):
     25        (WebKit::UIGamepadProvider::platformStartMonitoringInput):
     26        (WebKit::UIGamepadProvider::UIGamepadProvider): Deleted.
     27        (WebKit::UIGamepadProvider::scheduleDisableGamepadMonitoring): Deleted.
     28        (WebKit::UIGamepadProvider::disableMonitoringTimerFired): Deleted.
     29        * UIProcess/Gamepad/UIGamepadProvider.h:
     30       
     31        * UIProcess/Gamepad/mac/UIGamepadProviderHID.cpp:
     32        (WebKit::UIGamepadProvider::platformStopMonitoringInput):
     33        (WebKit::UIGamepadProvider::platformStartMonitoringInput):
     34       
     35        * UIProcess/WebProcessPool.cpp:
     36        (WebKit::WebProcessPool::setInitialConnectedGamepads):
     37        * UIProcess/WebProcessPool.h:
     38       
     39        * WebProcess/Gamepad/WebGamepadProvider.cpp:
     40        (WebKit::WebGamepadProvider::setInitialGamepads):
     41        * WebProcess/Gamepad/WebGamepadProvider.h:
     42       
     43        * WebProcess/WebProcess.cpp:
     44        (WebKit::WebProcess::setInitialGamepads):
     45        * WebProcess/WebProcess.h:
     46        * WebProcess/WebProcess.messages.in:
     47
    1482016-08-15  Simon Fraser  <simon.fraser@apple.com>
    249

  • trunk/Source/WebKit2/Platform/Logging.h

    r204509 r204524  
    4444#define WEBKIT2_LOG_CHANNELS(M) \
    4545    M(ContextMenu) \
     46    M(Gamepad) \
    4647    M(IDB) \
    4748    M(IconDatabase) \

  • trunk/Source/WebKit2/UIProcess/Gamepad/UIGamepadProvider.cpp

    r204509 r204524  
    4949UIGamepadProvider::UIGamepadProvider()
    5050    : m_gamepadSyncTimer(RunLoop::main(), this, &UIGamepadProvider::gamepadSyncTimerFired)
    51     , m_disableMonitoringTimer(RunLoop::main(), this, &UIGamepadProvider::disableMonitoringTimerFired)
    5251{
    5352}
    … …  
    6564        return;
    6665
     66    webPageProxy->gamepadActivity(snapshotGamepads());
     67}
     68
     69void UIGamepadProvider::scheduleGamepadStateSync()
     70{
     71    if (!m_isMonitoringGamepads || m_gamepadSyncTimer.isActive())
     72        return;
     73
     74    if (m_gamepads.isEmpty() || m_processPoolsUsingGamepads.isEmpty()) {
     75        m_gamepadSyncTimer.stop();
     76        return;
     77    }
     78
     79    m_gamepadSyncTimer.startOneShot(maximumGamepadUpdateInterval);
     80}
     81
     82void UIGamepadProvider::setInitialConnectedGamepads(const Vector<PlatformGamepad*>& initialGamepads)
     83{
     84    ASSERT(!m_hasInitialGamepads);
     85
     86    m_gamepads.resize(initialGamepads.size());
     87
     88    for (auto* gamepad : initialGamepads) {
     89        if (!gamepad)
     90            continue;
     91        m_gamepads[gamepad->index()] = std::make_unique<UIGamepad>(*gamepad);
     92    }
     93
     94    for (auto& pool : m_processPoolsUsingGamepads)
     95        pool->setInitialConnectedGamepads(m_gamepads);
     96
     97    m_hasInitialGamepads = true;
     98}
     99
     100void UIGamepadProvider::platformGamepadConnected(PlatformGamepad& gamepad)
     101{
     102    if (m_gamepads.size() <= gamepad.index())
     103        m_gamepads.resize(gamepad.index() + 1);
     104
     105    ASSERT(!m_gamepads[gamepad.index()]);
     106    m_gamepads[gamepad.index()] = std::make_unique<UIGamepad>(gamepad);
     107
     108    scheduleGamepadStateSync();
     109
     110    for (auto& pool : m_processPoolsUsingGamepads)
     111        pool->gamepadConnected(*m_gamepads[gamepad.index()]);
     112}
     113
     114void UIGamepadProvider::platformGamepadDisconnected(PlatformGamepad& gamepad)
     115{
     116    ASSERT(gamepad.index() < m_gamepads.size());
     117    ASSERT(m_gamepads[gamepad.index()]);
     118
     119    std::unique_ptr<UIGamepad> disconnectedGamepad = WTFMove(m_gamepads[gamepad.index()]);
     120
     121    scheduleGamepadStateSync();
     122
     123    for (auto& pool : m_processPoolsUsingGamepads)
     124        pool->gamepadDisconnected(*disconnectedGamepad);
     125}
     126
     127void UIGamepadProvider::platformGamepadInputActivity()
     128{
     129    auto platformGamepads = this->platformGamepads();
     130    ASSERT(platformGamepads.size() == m_gamepads.size());
     131
     132    for (size_t i = 0; i < platformGamepads.size(); ++i) {
     133        if (!platformGamepads[i]) {
     134            ASSERT(!m_gamepads[i]);
     135            continue;
     136        }
     137
     138        ASSERT(m_gamepads[i]);
     139        m_gamepads[i]->updateFromPlatformGamepad(*platformGamepads[i]);
     140    }
     141
     142    scheduleGamepadStateSync();
     143}
     144
     145void UIGamepadProvider::processPoolStartedUsingGamepads(WebProcessPool& pool)
     146{
     147    ASSERT(!m_processPoolsUsingGamepads.contains(&pool));
     148    m_processPoolsUsingGamepads.add(&pool);
     149
     150    if (!m_isMonitoringGamepads && platformWebPageProxyForGamepadInput())
     151        startMonitoringGamepads();
     152
     153    scheduleGamepadStateSync();
     154}
     155
     156void UIGamepadProvider::processPoolStoppedUsingGamepads(WebProcessPool& pool)
     157{
     158    ASSERT(m_processPoolsUsingGamepads.contains(&pool));
     159    m_processPoolsUsingGamepads.remove(&pool);
     160
     161    if (m_isMonitoringGamepads && !platformWebPageProxyForGamepadInput())
     162        platformStopMonitoringInput();
     163
     164    scheduleGamepadStateSync();
     165}
     166
     167void UIGamepadProvider::viewBecameActive(WebPageProxy& page)
     168{
     169    if (!m_processPoolsUsingGamepads.contains(&page.process().processPool()))
     170        return;
     171
     172    if (!m_isMonitoringGamepads)
     173        startMonitoringGamepads();
     174
     175    if (platformWebPageProxyForGamepadInput())
     176        platformStartMonitoringInput();
     177}
     178
     179void UIGamepadProvider::viewBecameInactive(WebPageProxy& page)
     180{
     181    auto pageForGamepadInput = platformWebPageProxyForGamepadInput();
     182    if (pageForGamepadInput == &page)
     183        platformStopMonitoringInput();
     184}
     185
     186void UIGamepadProvider::startMonitoringGamepads()
     187{
     188    if (m_isMonitoringGamepads)
     189        return;
     190
     191    m_isMonitoringGamepads = true;
     192    platformStartMonitoringGamepads();
     193}
     194
     195void UIGamepadProvider::stopMonitoringGamepads()
     196{
     197    if (!m_isMonitoringGamepads)
     198        return;
     199
     200    m_isMonitoringGamepads = false;
     201    platformStopMonitoringGamepads();
     202    m_gamepads.clear();
     203}
     204
     205Vector<GamepadData> UIGamepadProvider::snapshotGamepads()
     206{
    67207    Vector<GamepadData> gamepadDatas;
    68208    gamepadDatas.reserveInitialCapacity(m_gamepads.size());
    … …  
    75215    }
    76216
    77     webPageProxy->gamepadActivity(gamepadDatas);
    78 }
    79 
    80 void UIGamepadProvider::scheduleGamepadStateSync()
    81 {
    82     if (!m_isMonitoringGamepads || m_gamepadSyncTimer.isActive())
    83         return;
    84 
    85     if (m_gamepads.isEmpty() || m_processPoolsUsingGamepads.isEmpty()) {
    86         m_gamepadSyncTimer.stop();
    87         return;
    88     }
    89 
    90     m_gamepadSyncTimer.startOneShot(maximumGamepadUpdateInterval);
    91 }
    92 
    93 void UIGamepadProvider::platformGamepadConnected(PlatformGamepad& gamepad)
    94 {
    95     if (m_gamepads.size() <= gamepad.index())
    96         m_gamepads.resize(gamepad.index() + 1);
    97 
    98     ASSERT(!m_gamepads[gamepad.index()]);
    99     m_gamepads[gamepad.index()] = std::make_unique<UIGamepad>(gamepad);
    100 
    101     scheduleGamepadStateSync();
    102 
    103     for (auto& pool : m_processPoolsUsingGamepads)
    104         pool->gamepadConnected(*m_gamepads[gamepad.index()]);
    105 }
    106 
    107 void UIGamepadProvider::platformGamepadDisconnected(PlatformGamepad& gamepad)
    108 {
    109     ASSERT(gamepad.index() < m_gamepads.size());
    110     ASSERT(m_gamepads[gamepad.index()]);
    111 
    112     std::unique_ptr<UIGamepad> disconnectedGamepad = WTFMove(m_gamepads[gamepad.index()]);
    113 
    114     scheduleGamepadStateSync();
    115 
    116     for (auto& pool : m_processPoolsUsingGamepads)
    117         pool->gamepadDisconnected(*disconnectedGamepad);
    118 }
    119 
    120 void UIGamepadProvider::platformGamepadInputActivity()
    121 {
    122     auto platformGamepads = this->platformGamepads();
    123     ASSERT(platformGamepads.size() == m_gamepads.size());
    124 
    125     for (size_t i = 0; i < platformGamepads.size(); ++i) {
    126         if (!platformGamepads[i]) {
    127             ASSERT(!m_gamepads[i]);
    128             continue;
    129         }
    130 
    131         ASSERT(m_gamepads[i]);
    132         m_gamepads[i]->updateFromPlatformGamepad(*platformGamepads[i]);
    133     }
    134 
    135     scheduleGamepadStateSync();
    136 }
    137 
    138 void UIGamepadProvider::processPoolStartedUsingGamepads(WebProcessPool& pool)
    139 {
    140     ASSERT(!m_processPoolsUsingGamepads.contains(&pool));
    141     m_processPoolsUsingGamepads.add(&pool);
    142 
    143     if (!m_isMonitoringGamepads && platformWebPageProxyForGamepadInput())
    144         startMonitoringGamepads();
    145 
    146     scheduleGamepadStateSync();
    147 }
    148 
    149 void UIGamepadProvider::processPoolStoppedUsingGamepads(WebProcessPool& pool)
    150 {
    151     ASSERT(m_processPoolsUsingGamepads.contains(&pool));
    152     m_processPoolsUsingGamepads.remove(&pool);
    153 
    154     if (m_isMonitoringGamepads && !platformWebPageProxyForGamepadInput())
    155         scheduleDisableGamepadMonitoring();
    156 
    157     scheduleGamepadStateSync();
    158 }
    159 
    160 void UIGamepadProvider::viewBecameActive(WebPageProxy& page)
    161 {
    162     if (!m_processPoolsUsingGamepads.contains(&page.process().processPool()))
    163         return;
    164 
    165     m_disableMonitoringTimer.stop();
    166     startMonitoringGamepads();
    167 }
    168 
    169 void UIGamepadProvider::viewBecameInactive(WebPageProxy& page)
    170 {
    171     auto pageForGamepadInput = platformWebPageProxyForGamepadInput();
    172     if (pageForGamepadInput == &page)
    173         scheduleDisableGamepadMonitoring();
    174 }
    175 
    176 void UIGamepadProvider::scheduleDisableGamepadMonitoring()
    177 {
    178     if (!m_disableMonitoringTimer.isActive())
    179         m_disableMonitoringTimer.startOneShot(0);
    180 }
    181 
    182 void UIGamepadProvider::disableMonitoringTimerFired()
    183 {
    184     stopMonitoringGamepads();
    185 }
    186 
    187 void UIGamepadProvider::startMonitoringGamepads()
    188 {
    189     if (m_isMonitoringGamepads)
    190         return;
    191 
    192     m_isMonitoringGamepads = true;
    193     platformStartMonitoringGamepads();
    194 }
    195 
    196 void UIGamepadProvider::stopMonitoringGamepads()
    197 {
    198     if (!m_isMonitoringGamepads)
    199         return;
    200 
    201     m_isMonitoringGamepads = false;
    202     platformStopMonitoringGamepads();
     217    return gamepadDatas;
    203218}
    204219
    … …  
    228243}
    229244
     245void UIGamepadProvider::platformStopMonitoringInput()
     246{
     247}
     248
     249void UIGamepadProvider::platformStartMonitoringInput()
     250{
     251}
     252
    230253#endif // !PLATFORM(MAC)
    231254

  • trunk/Source/WebKit2/UIProcess/Gamepad/UIGamepadProvider.h

    r204509 r204524  
    6565    const Vector<WebCore::PlatformGamepad*>& platformGamepads();
    6666    WebPageProxy* platformWebPageProxyForGamepadInput();
     67    void platformStopMonitoringInput();
     68    void platformStartMonitoringInput();
    6769
     70    void setInitialConnectedGamepads(const Vector<WebCore::PlatformGamepad*>&) final;
    6871    void platformGamepadConnected(WebCore::PlatformGamepad&) final;
    6972    void platformGamepadDisconnected(WebCore::PlatformGamepad&) final;
    … …  
    7376    void gamepadSyncTimerFired();
    7477
    75     void scheduleDisableGamepadMonitoring();
    76     void disableMonitoringTimerFired();
     78    Vector<GamepadData> snapshotGamepads();
    7779
    7880    HashSet<WebProcessPool*> m_processPoolsUsingGamepads;
    … …  
    8183
    8284    RunLoop::Timer<UIGamepadProvider> m_gamepadSyncTimer;
    83     RunLoop::Timer<UIGamepadProvider> m_disableMonitoringTimer;
    8485
    8586    bool m_isMonitoringGamepads { false };
     87    bool m_hasInitialGamepads { false };
    8688};
    8789

  • trunk/Source/WebKit2/UIProcess/Gamepad/mac/UIGamepadProviderHID.cpp

    r204509 r204524  
    5252}
    5353
     54void UIGamepadProvider::platformStopMonitoringInput()
     55{
     56    return HIDGamepadProvider::singleton().stopMonitoringInput();
     57}
     58
     59void UIGamepadProvider::platformStartMonitoringInput()
     60{
     61    return HIDGamepadProvider::singleton().startMonitoringInput();
     62}
     63
    5464}
    5565

  • trunk/Source/WebKit2/UIProcess/WebProcessPool.cpp

    r204509 r204524  
    12871287}
    12881288
     1289void WebProcessPool::setInitialConnectedGamepads(const Vector<std::unique_ptr<UIGamepad>>& gamepads)
     1290{
     1291    Vector<GamepadData> gamepadDatas;
     1292    gamepadDatas.resize(gamepads.size());
     1293    for (size_t i = 0; i < gamepads.size(); ++i) {
     1294        if (!gamepads[i])
     1295            continue;
     1296        gamepadDatas[i] = gamepads[i]->gamepadData();
     1297    }
     1298
     1299    for (auto& process : m_processesUsingGamepads)
     1300        process->send(Messages::WebProcess::SetInitialGamepads(gamepadDatas), 0);
     1301}
     1302
    12891303#endif // ENABLE(GAMEPAD)
    12901304

  • trunk/Source/WebKit2/UIProcess/WebProcessPool.h

    r204509 r204524  
    371371    void gamepadConnected(const UIGamepad&);
    372372    void gamepadDisconnected(const UIGamepad&);
     373
     374    void setInitialConnectedGamepads(const Vector<std::unique_ptr<UIGamepad>>&);
    373375#endif
    374376

  • trunk/Source/WebKit2/WebProcess/Gamepad/WebGamepadProvider.cpp

    r204509 r204524  
    5252WebGamepadProvider::~WebGamepadProvider()
    5353{
     54}
     55
     56void WebGamepadProvider::setInitialGamepads(const Vector<GamepadData>& gamepadDatas)
     57{
     58    ASSERT(m_gamepads.isEmpty());
     59
     60    m_gamepads.resize(gamepadDatas.size());
     61    m_rawGamepads.resize(gamepadDatas.size());
     62    for (size_t i = 0; i < gamepadDatas.size(); ++i) {
     63        if (gamepadDatas[i].isNull())
     64            continue;
     65
     66        m_gamepads[i] = std::make_unique<WebGamepad>(gamepadDatas[i]);
     67        m_rawGamepads[i] = m_gamepads[i].get();
     68    }
    5469}
    5570

  • trunk/Source/WebKit2/WebProcess/Gamepad/WebGamepadProvider.h

    r204509 r204524  
    4747    void gamepadActivity(const Vector<GamepadData>&);
    4848
     49    void setInitialGamepads(const Vector<GamepadData>&);
     50
    4951private:
    5052    friend NeverDestroyed<WebGamepadProvider>;

  • trunk/Source/WebKit2/WebProcess/WebProcess.cpp

    r204509 r204524  
    10311031#if ENABLE(GAMEPAD)
    10321032
     1033void WebProcess::setInitialGamepads(const Vector<WebKit::GamepadData>& gamepadDatas)
     1034{
     1035    WebGamepadProvider::singleton().setInitialGamepads(gamepadDatas);
     1036}
     1037
    10331038void WebProcess::gamepadConnected(const GamepadData& gamepadData)
    10341039{

  • trunk/Source/WebKit2/WebProcess/WebProcess.h

    r204509 r204524  
    277277
    278278#if ENABLE(GAMEPAD)
     279    void setInitialGamepads(const Vector<GamepadData>&);
    279280    void gamepadConnected(const GamepadData&);
    280281    void gamepadDisconnected(unsigned index);

  • trunk/Source/WebKit2/WebProcess/WebProcess.messages.in

    r204509 r204524  
    104104
    105105#if ENABLE(GAMEPAD)
     106    SetInitialGamepads(Vector<WebKit::GamepadData> gamepadDatas)
    106107    GamepadConnected(struct WebKit::GamepadData gamepadData)
    107108    GamepadDisconnected(unsigned index)
Note: See TracChangeset for help on using the changeset viewer.