Changeset 293173 in webkit


Ignore:
Timestamp:
Apr 21, 2022 9:55:46 AM (3 months ago)
Author:
youenn@apple.com
Message:

A suspended remote shared worker should resume when a new SharedWorker is added
​https://bugs.webkit.org/show_bug.cgi?id=239325

Reviewed by Chris Dumez.

Source/WebKit:

Check whether resuming/suspending remote shared worker in case of added/removed SharedWorker object.
Make sure to suspend the remote shared worker at launch time if needed.

Covered by updated test.

  • NetworkProcess/SharedWorker/WebSharedWorker.cpp:
  • NetworkProcess/SharedWorker/WebSharedWorker.h:
  • NetworkProcess/SharedWorker/WebSharedWorkerServer.cpp:

LayoutTests:

  • http/tests/navigation/page-cache-shared-worker-expected.txt:
  • http/tests/navigation/page-cache-shared-worker.html:
  • http/tests/navigation/resources/page-cache-helper-for-sharedworker.html:
  • http/tests/navigation/resources/shared-worker-script.js:
Location:
trunk
Files:
9 edited

Legend:

Unmodified
Added
Removed

  • trunk/LayoutTests/ChangeLog

    r293171 r293173  
     12022-04-21  Youenn Fablet  <youenn@apple.com>
     2
     3        A suspended remote shared worker should resume when a new SharedWorker is added
     4        https://bugs.webkit.org/show_bug.cgi?id=239325
     5
     6        Reviewed by Chris Dumez.
     7
     8        * http/tests/navigation/page-cache-shared-worker-expected.txt:
     9        * http/tests/navigation/page-cache-shared-worker.html:
     10        * http/tests/navigation/resources/page-cache-helper-for-sharedworker.html:
     11        * http/tests/navigation/resources/shared-worker-script.js:
     12
    1132022-04-21  Karl Rackler  <rackler@apple.com>
    214

  • trunk/LayoutTests/http/tests/navigation/page-cache-shared-worker-expected.txt

    r292860 r293173  
    99PASS Page did enter and was restored from the page cache
    1010PASS counter is below 100
     11PASS state is "hungry"
    1112PASS successfullyParsed is true
    1213

  • trunk/LayoutTests/http/tests/navigation/page-cache-shared-worker.html

    r292860 r293173  
    99
    1010var restoredFromPageCache = false;
    11 var sw;
     11var sw1, sw2;
     12var state;
    1213
    1314window.addEventListener("pageshow", async function(event) {
    … …  
    1819        restoredFromPageCache = true;
    1920
    20         sw.port.postMessage('counter');
    21         const counter = await new Promise(resolve => sw.port.onmessage = (event) => resolve(event.data));
     21        sw1.port.postMessage('counter');
     22        const counter = await new Promise(resolve => sw1.port.onmessage = (event) => resolve(event.data));
    2223        if (counter < 100)
    2324            testPassed("counter is below 100");
    2425        else
    2526            testFailed("counter is above 100");
     27
     28        sw2.port.postMessage('getState');
     29        state = await new Promise(resolve => sw2.port.onmessage = (event) => resolve(event.data));
     30        shouldBeEqualToString("state", "hungry");
    2631
    2732        setTimeout(finishJSTest, 0);
    … …  
    3843
    3944window.addEventListener('load', function() {
    40     sw = new SharedWorker('resources/shared-worker-script.js');
     45    sw1 = new SharedWorker('resources/shared-worker-script.js?1');
     46    sw2 = new SharedWorker('resources/shared-worker-script.js?2');
    4147    setTimeout(function() {
    4248      // Force a back navigation back to this page.

  • trunk/LayoutTests/http/tests/navigation/resources/page-cache-helper-for-sharedworker.html

    r292860 r293173  
    1111
    1212    channel.postMessage('ping');
    13     return new Promise((resolve, reject) => {
     13    await new Promise((resolve, reject) => {
    1414         let myTimer = setTimeout(resolve, 1000);
    1515         channel.onmessage = async () => {
    … …  
    2020         };
    2121    });
     22
     23    const sw2 = new SharedWorker('shared-worker-script.js?2');
     24    sw2.port.postMessage({ action: 'setState', state: 'hungry' });
     25    await new Promise(resolve => sw2.port.onmessage = resolve);
    2226}
    2327

  • trunk/LayoutTests/http/tests/navigation/resources/shared-worker-script.js

    r292860 r293173  
    11var channel = new BroadcastChannel('shared-worker');
    22var counter = 0;
     3var state = 'empty';
    34channel.onmessage = (event) => {
    45    if (event.data === 'ping') {
    … …  
    1011    const port = e.ports[0];
    1112    port.onmessage = (event) => {
    12         if (event.data === 'counter')
     13        if (event.data === 'counter') {
    1314            port.postMessage(counter);
     15            return;
     16        }
     17        if (event.data === 'getState') {
     18            port.postMessage(state);
     19            return;
     20        }
     21        if (event.data.action === 'setState') {
     22            state = event.data.state;
     23            port.postMessage('ok');
     24        }
    1425    };
    1526}

  • trunk/Source/WebKit/ChangeLog

    r293170 r293173  
     12022-04-21  Youenn Fablet  <youenn@apple.com>
     2
     3        A suspended remote shared worker should resume when a new SharedWorker is added
     4        https://bugs.webkit.org/show_bug.cgi?id=239325
     5
     6        Reviewed by Chris Dumez.
     7
     8        Check whether resuming/suspending remote shared worker in case of added/removed SharedWorker object.
     9        Make sure to suspend the remote shared worker at launch time if needed.
     10
     11        Covered by updated test.
     12
     13        * NetworkProcess/SharedWorker/WebSharedWorker.cpp:
     14        * NetworkProcess/SharedWorker/WebSharedWorker.h:
     15        * NetworkProcess/SharedWorker/WebSharedWorkerServer.cpp:
     16
    1172022-04-21  Eric Carlson  <eric.carlson@apple.com>
    218

  • trunk/Source/WebKit/NetworkProcess/SharedWorker/WebSharedWorker.cpp

    r292860 r293173  
    7373}
    7474
     75void WebSharedWorker::setFetchResult(WebCore::WorkerFetchResult&& fetchResult, WebSharedWorkerServerToContextConnection* contextConnection)
     76{
     77    m_fetchResult = WTFMove(fetchResult);
     78    if (contextConnection)
     79        launch(*contextConnection);
     80}
     81
    7582void WebSharedWorker::didCreateContextConnection(WebSharedWorkerServerToContextConnection& contextConnection)
    7683{
    7784    for (auto& sharedWorkerObjectIdentifier : m_sharedWorkerObjects.keys())
    7885        contextConnection.addSharedWorkerObject(sharedWorkerObjectIdentifier);
     86    if (didFinishFetching())
     87        launch(contextConnection);
     88}
     89
     90void WebSharedWorker::launch(WebSharedWorkerServerToContextConnection& connection)
     91{
     92    connection.launchSharedWorker(*this);
     93    if (m_isSuspended)
     94        connection.suspendSharedWorker(identifier());
    7995}
    8096
    … …  
    84100    if (auto* connection = contextConnection())
    85101        connection->addSharedWorkerObject(sharedWorkerObjectIdentifier);
     102
     103    resumeIfNeeded();
    86104}
    87105
    … …  
    91109    if (auto* connection = contextConnection())
    92110        connection->removeSharedWorkerObject(sharedWorkerObjectIdentifier);
     111
     112    suspendIfNeeded();
    93113}
    94114
    … …  
    101121    iterator->value.isSuspended = true;
    102122    ASSERT(!m_isSuspended);
     123
     124    suspendIfNeeded();
     125}
     126
     127void WebSharedWorker::suspendIfNeeded()
     128{
    103129    if (m_isSuspended)
    104130        return;
    … …  
    121147
    122148    iterator->value.isSuspended = false;
     149
     150    resumeIfNeeded();
     151}
     152
     153void WebSharedWorker::resumeIfNeeded()
     154{
    123155    if (!m_isSuspended)
    124156        return;

  • trunk/Source/WebKit/NetworkProcess/SharedWorker/WebSharedWorker.h

    r292860 r293173  
    7373
    7474    const WebCore::WorkerFetchResult& fetchResult() const { return m_fetchResult; }
    75     void setFetchResult(WebCore::WorkerFetchResult&& fetchResult) { m_fetchResult = WTFMove(fetchResult); }
     75    void setFetchResult(WebCore::WorkerFetchResult&&, WebSharedWorkerServerToContextConnection*);
    7676    bool didFinishFetching() const { return !!m_fetchResult.script; }
    7777
    … …  
    8181    WebSharedWorker(const WebSharedWorker&) = delete;
    8282    WebSharedWorker& operator=(const WebSharedWorker&) = delete;
     83
     84    void suspendIfNeeded();
     85    void resumeIfNeeded();
     86    void launch(WebSharedWorkerServerToContextConnection&);
    8387
    8488    struct SharedWorkerObjectState {

  • trunk/Source/WebKit/NetworkProcess/SharedWorker/WebSharedWorkerServer.cpp

    r292860 r293173  
    108108    }
    109109
    110     sharedWorker.setFetchResult(WTFMove(fetchResult));
    111 
    112     if (auto* contextConnection = sharedWorker.contextConnection()) {
    113         contextConnection->launchSharedWorker(sharedWorker);
    114         return;
    115     }
    116     createContextConnection(sharedWorker.registrableDomain(), sharedWorker.firstSharedWorkerObjectProcess());
     110    auto* connection = m_contextConnections.get(sharedWorker.registrableDomain());
     111    sharedWorker.setFetchResult(WTFMove(fetchResult), connection);
     112
     113    if (!connection)
     114        createContextConnection(sharedWorker.registrableDomain(), sharedWorker.firstSharedWorkerObjectProcess());
    117115}
    118116
    … …  
    187185
    188186        sharedWorker->didCreateContextConnection(contextConnection);
    189         if (sharedWorker->didFinishFetching())
    190             contextConnection.launchSharedWorker(*sharedWorker);
    191187    }
    192188}
Note: See TracChangeset for help on using the changeset viewer.