Changeset 204509 in webkit


Ignore:
Timestamp:
Aug 16, 2016 9:57:17 AM (8 years ago)
Author:
Chris Dumez
Message:

Unreviewed, rolling out r204506.

Broke the build

Reverted changeset:

"Cleanup WK2 platform gamepad handling."
​https://bugs.webkit.org/show_bug.cgi?id=160871
​http://trac.webkit.org/changeset/204506

Location:
trunk/Source
Files:
16 edited

Legend:

Unmodified
Added
Removed

  • trunk/Source/WebCore/ChangeLog

    r204508 r204509  
     12016-08-16  Chris Dumez  <cdumez@apple.com>
     2
     3        Unreviewed, rolling out r204506.
     4
     5        Broke the build
     6
     7        Reverted changeset:
     8
     9        "Cleanup WK2 platform gamepad handling."
     10        https://bugs.webkit.org/show_bug.cgi?id=160871
     11        http://trac.webkit.org/changeset/204506
     12
    1132016-08-16  Darin Adler  <darin@apple.com>
    214

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

    r204506 r204509  
    2828#if ENABLE(GAMEPAD)
    2929
    30 #include <wtf/Vector.h>
    31 
    3230namespace WebCore {
    3331
    … …  
    3836    virtual ~GamepadProviderClient() { }
    3937
    40     virtual void setInitialConnectedGamepads(const Vector<PlatformGamepad*>&) { }
    4138    virtual void platformGamepadConnected(PlatformGamepad&) = 0;
    4239    virtual void platformGamepadDisconnected(PlatformGamepad&) = 0;

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

    r204506 r204509  
    9797    IOHIDManagerRegisterDeviceMatchingCallback(m_manager.get(), deviceAddedCallback, this);
    9898    IOHIDManagerRegisterDeviceRemovalCallback(m_manager.get(), deviceRemovedCallback, this);
    99 
    100     startMonitoringInput();
    101 }
    102 
    103 void HIDGamepadProvider::stopMonitoringInput()
    104 {
    105     IOHIDManagerRegisterInputValueCallback(m_manager.get(), nullptr, nullptr);
    106 }
    107 
    108 void HIDGamepadProvider::startMonitoringInput()
    109 {
    11099    IOHIDManagerRegisterInputValueCallback(m_manager.get(), deviceValuesChangedCallback, this);
    111100}
    … …  
    123112{
    124113    m_shouldDispatchCallbacks = true;
    125 
    126     for (auto* client : m_clients)
    127         client->setInitialConnectedGamepads(m_gamepadVector);
    128114}
    129115

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

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

  • trunk/Source/WebKit2/ChangeLog

    r204508 r204509  
     12016-08-16  Chris Dumez  <cdumez@apple.com>
     2
     3        Unreviewed, rolling out r204506.
     4
     5        Broke the build
     6
     7        Reverted changeset:
     8
     9        "Cleanup WK2 platform gamepad handling."
     10        https://bugs.webkit.org/show_bug.cgi?id=160871
     11        http://trac.webkit.org/changeset/204506
     12
    1132016-08-16  Darin Adler  <darin@apple.com>
    214

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

    r204506 r204509  
    4444#define WEBKIT2_LOG_CHANNELS(M) \
    4545    M(ContextMenu) \
    46     M(Gamepad) \
    4746    M(IDB) \
    4847    M(IconDatabase) \

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

    r204506 r204509  
    4949UIGamepadProvider::UIGamepadProvider()
    5050    : m_gamepadSyncTimer(RunLoop::main(), this, &UIGamepadProvider::gamepadSyncTimerFired)
     51    , m_disableMonitoringTimer(RunLoop::main(), this, &UIGamepadProvider::disableMonitoringTimerFired)
    5152{
    5253}
    … …  
    6465        return;
    6566
    66     webPageProxy->gamepadActivity(snapshotGamepads());
    67 }
    68 
    69 void 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 
    82 void 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 
    100 void 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 
    114 void 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 
    127 void 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 
    145 void 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 
    156 void 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 
    167 void 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 
    179 void UIGamepadProvider::viewBecameInactive(WebPageProxy& page)
    180 {
    181     auto pageForGamepadInput = platformWebPageProxyForGamepadInput();
    182     if (pageForGamepadInput == &page)
    183         platformStopMonitoringInput();
    184 }
    185 
    186 void UIGamepadProvider::startMonitoringGamepads()
    187 {
    188     if (m_isMonitoringGamepads)
    189         return;
    190 
    191     m_isMonitoringGamepads = true;
    192     platformStartMonitoringGamepads();
    193 }
    194 
    195 void UIGamepadProvider::stopMonitoringGamepads()
    196 {
    197     if (!m_isMonitoringGamepads)
    198         return;
    199 
    200     m_isMonitoringGamepads = false;
    201     platformStopMonitoringGamepads();
    202     m_gamepads.clear();
    203 }
    204 
    205 Vector<GamepadData> UIGamepadProvider::snapshotGamepads()
    206 {
    20767    Vector<GamepadData> gamepadDatas;
    20868    gamepadDatas.reserveInitialCapacity(m_gamepads.size());
    … …  
    21575    }
    21676
    217     return gamepadDatas;
     77    webPageProxy->gamepadActivity(gamepadDatas);
     78}
     79
     80void 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
     93void 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
     107void 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
     120void 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
     138void 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
     149void 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
     160void UIGamepadProvider::viewBecameActive(WebPageProxy& page)
     161{
     162    if (!m_processPoolsUsingGamepads.contains(&page.process().processPool()))
     163        return;
     164
     165    m_disableMonitoringTimer.stop();
     166    startMonitoringGamepads();
     167}
     168
     169void UIGamepadProvider::viewBecameInactive(WebPageProxy& page)
     170{
     171    auto pageForGamepadInput = platformWebPageProxyForGamepadInput();
     172    if (pageForGamepadInput == &page)
     173        scheduleDisableGamepadMonitoring();
     174}
     175
     176void UIGamepadProvider::scheduleDisableGamepadMonitoring()
     177{
     178    if (!m_disableMonitoringTimer.isActive())
     179        m_disableMonitoringTimer.startOneShot(0);
     180}
     181
     182void UIGamepadProvider::disableMonitoringTimerFired()
     183{
     184    stopMonitoringGamepads();
     185}
     186
     187void UIGamepadProvider::startMonitoringGamepads()
     188{
     189    if (m_isMonitoringGamepads)
     190        return;
     191
     192    m_isMonitoringGamepads = true;
     193    platformStartMonitoringGamepads();
     194}
     195
     196void UIGamepadProvider::stopMonitoringGamepads()
     197{
     198    if (!m_isMonitoringGamepads)
     199        return;
     200
     201    m_isMonitoringGamepads = false;
     202    platformStopMonitoringGamepads();
    218203}
    219204
    … …  
    243228}
    244229
    245 void UIGamepadProvider::platformStopMonitoringInput()
    246 {
    247 }
    248 
    249 void UIGamepadProvider::platformStartMonitoringInput()
    250 {
    251 }
    252 
    253230#endif // !PLATFORM(MAC)
    254231

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

    r204506 r204509  
    6565    const Vector<WebCore::PlatformGamepad*>& platformGamepads();
    6666    WebPageProxy* platformWebPageProxyForGamepadInput();
    67     void platformStopMonitoringInput();
    68     void platformStartMonitoringInput();
    6967
    70     void setInitialConnectedGamepads(const Vector<WebCore::PlatformGamepad*>&) final;
    7168    void platformGamepadConnected(WebCore::PlatformGamepad&) final;
    7269    void platformGamepadDisconnected(WebCore::PlatformGamepad&) final;
    … …  
    7673    void gamepadSyncTimerFired();
    7774
    78     Vector<GamepadData> snapshotGamepads();
     75    void scheduleDisableGamepadMonitoring();
     76    void disableMonitoringTimerFired();
    7977
    8078    HashSet<WebProcessPool*> m_processPoolsUsingGamepads;
    … …  
    8381
    8482    RunLoop::Timer<UIGamepadProvider> m_gamepadSyncTimer;
     83    RunLoop::Timer<UIGamepadProvider> m_disableMonitoringTimer;
    8584
    8685    bool m_isMonitoringGamepads { false };
    87     bool m_hasInitialGamepads { false };
    8886};
    8987

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

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

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

    r204506 r204509  
    12871287}
    12881288
    1289 void 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 
    13031289#endif // ENABLE(GAMEPAD)
    13041290

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

    r204506 r204509  
    371371    void gamepadConnected(const UIGamepad&);
    372372    void gamepadDisconnected(const UIGamepad&);
    373 
    374     void setInitialConnectedGamepads(const Vector<std::unique_ptr<UIGamepad>>&);
    375373#endif
    376374

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

    r204506 r204509  
    5252WebGamepadProvider::~WebGamepadProvider()
    5353{
    54 }
    55 
    56 void 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     }
    6954}
    7055

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

    r204506 r204509  
    4747    void gamepadActivity(const Vector<GamepadData>&);
    4848
    49     void setInitialGamepads(const Vector<GamepadData>&);
    50 
    5149private:
    5250    friend NeverDestroyed<WebGamepadProvider>;

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

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

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

    r204506 r204509  
    277277
    278278#if ENABLE(GAMEPAD)
    279     void setInitialGamepads(const Vector<GamepadData>&);
    280279    void gamepadConnected(const GamepadData&);
    281280    void gamepadDisconnected(unsigned index);

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

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