Changeset 240363 in webkit


Ignore:
Timestamp:
Jan 23, 2019 3:34:22 PM (5 years ago)
Author:
Chris Dumez
Message:

Deprecate API to limit the maximum number of WebProcesses
​https://bugs.webkit.org/show_bug.cgi?id=193725
<rdar://problem/47464879>

Reviewed by Geoff Garen.

Source/WebKit:

Deprecate API to limit the maximum number of WebProcesses and make it a no-op. It adds
complexity and is not safe (conflicts with PSON).

Add a new usesSingleWebProcess SPI to _WKProcessPoolConfiguration to be used by
Minibrowser / Safari in order to disable process per tab (can be useful for debugging).
Note that enabling the single WebProcess mode will disable PSON and process prewarming.

  • UIProcess/API/APIProcessPoolConfiguration.cpp:

(API::ProcessPoolConfiguration::createWithLegacyOptions):
(API::ProcessPoolConfiguration::copy):

  • UIProcess/API/APIProcessPoolConfiguration.h:
  • UIProcess/API/C/WKContext.cpp:

(WKContextSetMaximumNumberOfProcesses):
(WKContextGetMaximumNumberOfProcesses):

  • UIProcess/API/C/WKContext.h:
  • UIProcess/API/Cocoa/WKProcessPool.mm:
  • UIProcess/API/Cocoa/WKProcessPoolPrivate.h:
  • UIProcess/API/Cocoa/_WKProcessPoolConfiguration.h:
  • UIProcess/API/Cocoa/_WKProcessPoolConfiguration.mm:

(-[_WKProcessPoolConfiguration maximumProcessCount]):
(-[_WKProcessPoolConfiguration setMaximumProcessCount:]):
(-[_WKProcessPoolConfiguration usesSingleWebProcess]):
(-[_WKProcessPoolConfiguration setUsesSingleWebProcess:]):
(-[_WKProcessPoolConfiguration description]):

  • UIProcess/API/glib/WebKitWebContext.cpp:

(webkitWebContextConstructed):
(webkit_web_context_set_process_model):
(webkit_web_context_set_web_process_count_limit):

  • UIProcess/WebProcessPool.cpp:

(WebKit::WebProcessPool::createNewWebProcessRespectingProcessCountLimit):
(WebKit::WebProcessPool::didReachGoodTimeToPrewarm):
(WebKit::WebProcessPool::processForNavigationInternal):

  • UIProcess/WebProcessPool.h:

Tools:

Update existing API tests to stop using deprecated API.

  • MiniBrowser/mac/AppDelegate.m:

(defaultConfiguration):

  • TestWebKitAPI/Tests/WebKit/UserMedia.cpp:

(TestWebKitAPI::TEST):

  • TestWebKitAPI/Tests/WebKitCocoa/ResponsivenessTimer.mm:

(TestWebKitAPI::TEST):

  • TestWebKitAPI/Tests/WebKitCocoa/ServiceWorkerBasic.mm:
  • TestWebKitAPI/Tests/WebKitCocoa/UserContentController.mm:

(TEST):

  • TestWebKitAPI/Tests/WebKitCocoa/WKProcessPoolConfiguration.mm:

(TEST):

Location:
trunk
Files:
19 edited

Legend:

Unmodified
Added
Removed

  • trunk/Source/WebKit/ChangeLog

    r240360 r240363  
     12019-01-23  Chris Dumez  <cdumez@apple.com>
     2
     3        Deprecate API to limit the maximum number of WebProcesses
     4        https://bugs.webkit.org/show_bug.cgi?id=193725
     5        <rdar://problem/47464879>
     6
     7        Reviewed by Geoff Garen.
     8
     9        Deprecate API to limit the maximum number of WebProcesses and make it a no-op. It adds
     10        complexity and is not safe (conflicts with PSON).
     11
     12        Add a new usesSingleWebProcess SPI to _WKProcessPoolConfiguration to be used by
     13        Minibrowser / Safari in order to disable process per tab (can be useful for debugging).
     14        Note that enabling the single WebProcess mode will disable PSON and process prewarming.
     15
     16        * UIProcess/API/APIProcessPoolConfiguration.cpp:
     17        (API::ProcessPoolConfiguration::createWithLegacyOptions):
     18        (API::ProcessPoolConfiguration::copy):
     19        * UIProcess/API/APIProcessPoolConfiguration.h:
     20        * UIProcess/API/C/WKContext.cpp:
     21        (WKContextSetMaximumNumberOfProcesses):
     22        (WKContextGetMaximumNumberOfProcesses):
     23        * UIProcess/API/C/WKContext.h:
     24        * UIProcess/API/Cocoa/WKProcessPool.mm:
     25        * UIProcess/API/Cocoa/WKProcessPoolPrivate.h:
     26        * UIProcess/API/Cocoa/_WKProcessPoolConfiguration.h:
     27        * UIProcess/API/Cocoa/_WKProcessPoolConfiguration.mm:
     28        (-[_WKProcessPoolConfiguration maximumProcessCount]):
     29        (-[_WKProcessPoolConfiguration setMaximumProcessCount:]):
     30        (-[_WKProcessPoolConfiguration usesSingleWebProcess]):
     31        (-[_WKProcessPoolConfiguration setUsesSingleWebProcess:]):
     32        (-[_WKProcessPoolConfiguration description]):
     33        * UIProcess/API/glib/WebKitWebContext.cpp:
     34        (webkitWebContextConstructed):
     35        (webkit_web_context_set_process_model):
     36        (webkit_web_context_set_web_process_count_limit):
     37        * UIProcess/WebProcessPool.cpp:
     38        (WebKit::WebProcessPool::createNewWebProcessRespectingProcessCountLimit):
     39        (WebKit::WebProcessPool::didReachGoodTimeToPrewarm):
     40        (WebKit::WebProcessPool::processForNavigationInternal):
     41        * UIProcess/WebProcessPool.h:
     42
    1432019-01-23  Brent Fulgham  <bfulgham@apple.com>
    244

  • trunk/Source/WebKit/UIProcess/API/APIProcessPoolConfiguration.cpp

    r239671 r240363  
    4242
    4343    configuration->m_shouldHaveLegacyDataStore = true;
    44     configuration->m_maximumProcessCount = 1;
    4544    configuration->m_cacheModel = WebKit::CacheModel::DocumentViewer;
    4645
    … …  
    9190
    9291    copy->m_shouldHaveLegacyDataStore = this->m_shouldHaveLegacyDataStore;
    93     copy->m_maximumProcessCount = this->m_maximumProcessCount;
    9492    copy->m_cacheModel = this->m_cacheModel;
    9593    copy->m_diskCacheDirectory = this->m_diskCacheDirectory;
    … …  
    134132#endif
    135133    copy->m_customWebContentServiceBundleIdentifier = this->m_customWebContentServiceBundleIdentifier;
     134    copy->m_usesSingleWebProcess = m_usesSingleWebProcess;
    136135
    137136    return copy;

  • trunk/Source/WebKit/UIProcess/API/APIProcessPoolConfiguration.h

    r239671 r240363  
    5757    void setShouldHaveLegacyDataStore(bool shouldHaveLegacyDataStore) { m_shouldHaveLegacyDataStore = shouldHaveLegacyDataStore; }
    5858
    59     unsigned maximumProcessCount() const { return m_maximumProcessCount; }
    60     void setMaximumProcessCount(unsigned maximumProcessCount) { m_maximumProcessCount = maximumProcessCount; }
     59    bool usesSingleWebProcess() const { return m_usesSingleWebProcess; }
     60    void setUsesSingleWebProcess(bool enabled) { m_usesSingleWebProcess = enabled; }
    6161
    6262    bool isAutomaticProcessWarmingEnabled() const
    … …  
    188188    bool m_shouldHaveLegacyDataStore { false };
    189189
    190     unsigned m_maximumProcessCount { 0 };
    191190    bool m_diskCacheSpeculativeValidationEnabled { false };
    192191    WebKit::CacheModel m_cacheModel { WebKit::CacheModel::PrimaryWebBrowser };
    … …  
    225224    WTF::String m_customWebContentServiceBundleIdentifier;
    226225    bool m_isJITEnabled { true };
     226    bool m_usesSingleWebProcess { false };
    227227
    228228#if PLATFORM(IOS_FAMILY)

  • trunk/Source/WebKit/UIProcess/API/C/WKContext.cpp

    r239631 r240363  
    327327}
    328328
    329 void WKContextSetMaximumNumberOfProcesses(WKContextRef contextRef, unsigned numberOfProcesses)
    330 {
    331     WebKit::toImpl(contextRef)->setMaximumNumberOfProcesses(numberOfProcesses);
    332 }
    333 
    334 unsigned WKContextGetMaximumNumberOfProcesses(WKContextRef contextRef)
    335 {
    336     return WebKit::toImpl(contextRef)->maximumNumberOfProcesses();
     329void WKContextSetMaximumNumberOfProcesses(WKContextRef, unsigned)
     330{
     331    // Deprecated.
     332}
     333
     334unsigned WKContextGetMaximumNumberOfProcesses(WKContextRef)
     335{
     336    // Deprecated.
     337    return std::numeric_limits<unsigned>::max();
    337338}
    338339
    … …  
    406407}
    407408
     409void WKContextSetUsesSingleWebProcess(WKContextRef contextRef, bool value)
     410{
     411    WebKit::toImpl(contextRef)->configuration().setUsesSingleWebProcess(value);
     412}
     413
     414bool WKContextGetUsesSingleWebProcess(WKContextRef contextRef)
     415{
     416    return WebKit::toImpl(contextRef)->configuration().usesSingleWebProcess();
     417}
     418
    408419void WKContextSetCustomWebContentServiceBundleIdentifier(WKContextRef contextRef, WKStringRef name)
    409420{

  • trunk/Source/WebKit/UIProcess/API/C/WKContext.h

    r239631 r240363  
    132132WK_EXPORT void WKContextSetProcessModel(WKContextRef, WKProcessModel);
    133133
    134 WK_EXPORT void WKContextSetMaximumNumberOfProcesses(WKContextRef context, unsigned numberOfProcesses);
    135 WK_EXPORT unsigned WKContextGetMaximumNumberOfProcesses(WKContextRef context);
     134WK_EXPORT void WKContextSetMaximumNumberOfProcesses(WKContextRef context, unsigned numberOfProcesses) WK_C_API_DEPRECATED;
     135WK_EXPORT unsigned WKContextGetMaximumNumberOfProcesses(WKContextRef context) WK_C_API_DEPRECATED;
     136
     137WK_EXPORT void WKContextSetUsesSingleWebProcess(WKContextRef, bool);
     138WK_EXPORT bool WKContextGetUsesSingleWebProcess(WKContextRef);
    136139
    137140WK_EXPORT void WKContextStartMemorySampler(WKContextRef context, WKDoubleRef interval);

  • trunk/Source/WebKit/UIProcess/API/Cocoa/WKProcessPool.mm

    r238937 r240363  
    198198{
    199199    _processPool->registerURLSchemeAsCanDisplayOnlyIfCanRequest(scheme);
    200 }
    201 
    202 - (void)_setMaximumNumberOfProcesses:(NSUInteger)value
    203 {
    204     _processPool->setMaximumNumberOfProcesses(value);
    205200}
    206201

  • trunk/Source/WebKit/UIProcess/API/Cocoa/WKProcessPoolPrivate.h

    r238937 r240363  
    115115- (void)_setAllowsAnySSLCertificateForServiceWorker:(BOOL)allows WK_API_AVAILABLE(macosx(10.13.4), ios(11.3));
    116116- (void)_registerURLSchemeServiceWorkersCanHandle:(NSString *)scheme WK_API_AVAILABLE(macosx(10.13.4), ios(11.3));
    117 - (void)_setMaximumNumberOfProcesses:(NSUInteger)value WK_API_AVAILABLE(macosx(10.13.4), ios(11.3));
    118117- (void)_getActivePagesOriginsInWebProcessForTesting:(pid_t)pid completionHandler:(void(^)(NSArray<NSString *> *))completionHandler WK_API_AVAILABLE(macosx(WK_MAC_TBA), ios(WK_IOS_TBA));
    119118- (BOOL)_networkProcessHasEntitlementForTesting:(NSString *)entitlement WK_API_AVAILABLE(macosx(WK_MAC_TBA), ios(WK_IOS_TBA));

  • trunk/Source/WebKit/UIProcess/API/Cocoa/_WKProcessPoolConfiguration.h

    r238820 r240363  
    3535
    3636@property (nonatomic, copy) NSURL *injectedBundleURL;
    37 @property (nonatomic) NSUInteger maximumProcessCount;
     37@property (nonatomic) NSUInteger maximumProcessCount WK_API_DEPRECATED("It is no longer possible to limit the number of processes", macosx(WK_MAC_TBA, WK_MAC_TBA), ios(WK_IOS_TBA, WK_IOS_TBA));
     38@property (nonatomic) BOOL usesSingleWebProcess WK_API_AVAILABLE(macosx(WK_MAC_TBA), ios(WK_IOS_TBA));
    3839@property (nonatomic, nullable, copy) NSString *customWebContentServiceBundleIdentifier WK_API_AVAILABLE(macosx(WK_MAC_TBA), ios(WK_IOS_TBA));
    3940

  • trunk/Source/WebKit/UIProcess/API/Cocoa/_WKProcessPoolConfiguration.mm

    r239671 r240363  
    6565- (NSUInteger)maximumProcessCount
    6666{
    67     return _processPoolConfiguration->maximumProcessCount();
     67    // Deprecated.
     68    return NSUIntegerMax;
    6869}
    6970
    7071- (void)setMaximumProcessCount:(NSUInteger)maximumProcessCount
    7172{
    72     _processPoolConfiguration->setMaximumProcessCount(maximumProcessCount);
     73    // Deprecated.
    7374}
    7475
    … …  
    291292}
    292293
     294- (BOOL)usesSingleWebProcess
     295{
     296    return _processPoolConfiguration->usesSingleWebProcess();
     297}
     298
     299- (void)setUsesSingleWebProcess:(BOOL)enabled
     300{
     301    _processPoolConfiguration->setUsesSingleWebProcess(enabled);
     302}
     303
    293304- (BOOL)suppressesConnectionTerminationOnSystemChange
    294305{
    … …  
    345356- (NSString *)description
    346357{
    347     NSString *description = [NSString stringWithFormat:@"<%@: %p; maximumProcessCount = %lu", NSStringFromClass(self.class), self, static_cast<unsigned long>([self maximumProcessCount])];
     358    NSString *description = [NSString stringWithFormat:@"<%@: %p", NSStringFromClass(self.class), self];
    348359
    349360    if (!_processPoolConfiguration->injectedBundlePath().isEmpty())

  • trunk/Source/WebKit/UIProcess/API/glib/WebKitWebContext.cpp

    r239671 r240363  
    335335    API::ProcessPoolConfiguration configuration;
    336336    configuration.setInjectedBundlePath(WebCore::FileSystem::stringFromFileSystemRepresentation(bundleFilename.get()));
    337     configuration.setMaximumProcessCount(1);
    338337    configuration.setDiskCacheSpeculativeValidationEnabled(true);
    339338
    … …  
    14961495
    14971496    context->priv->processModel = processModel;
    1498     switch (context->priv->processModel) {
    1499     case WEBKIT_PROCESS_MODEL_SHARED_SECONDARY_PROCESS:
    1500         context->priv->processPool->setMaximumNumberOfProcesses(1);
    1501         break;
    1502     case WEBKIT_PROCESS_MODEL_MULTIPLE_SECONDARY_PROCESSES:
    1503         context->priv->processPool->setMaximumNumberOfProcesses(context->priv->processCountLimit);
    1504         break;
    1505     }
    15061497}
    15071498
    … …  
    15461537
    15471538    context->priv->processCountLimit = limit;
    1548     if (context->priv->processModel != WEBKIT_PROCESS_MODEL_SHARED_SECONDARY_PROCESS)
    1549         context->priv->processPool->setMaximumNumberOfProcesses(limit);
    15501539}
    15511540

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

    r240360 r240363  
    405405}
    406406
    407 void WebProcessPool::setMaximumNumberOfProcesses(unsigned maximumNumberOfProcesses)
    408 {
    409     m_configuration->setMaximumProcessCount(maximumNumberOfProcesses);
    410 }
    411 
    412407void WebProcessPool::setCustomWebContentServiceBundleIdentifier(const String& customWebContentServiceBundleIdentifier)
    413408{
    … …  
    10871082WebProcessProxy& WebProcessPool::createNewWebProcessRespectingProcessCountLimit(WebsiteDataStore& websiteDataStore)
    10881083{
    1089     // FIXME: https://bugs.webkit.org/show_bug.cgi?id=168676
    1090     // Once WebsiteDataStores are truly per-view instead of per-process, remove this nonsense.
     1084    if (!usesSingleWebProcess())
     1085        return createNewWebProcess(websiteDataStore);
    10911086
    10921087#if PLATFORM(COCOA)
    … …  
    10961091#endif
    10971092
    1098     if (m_processes.size() < maximumNumberOfProcesses())
    1099         return createNewWebProcess(websiteDataStore);
    1100 
    1101     WebProcessProxy* processToReuse = nullptr;
    11021093    for (auto& process : m_processes) {
    11031094        if (mustMatchDataStore && &process->websiteDataStore() != &websiteDataStore)
    … …  
    11071098            continue;
    11081099#endif
    1109         // Choose the process with fewest pages.
    1110         if (!processToReuse || processToReuse->pageCount() > process->pageCount())
    1111             processToReuse = process.get();
    1112     }
    1113     return processToReuse ? *processToReuse : createNewWebProcess(websiteDataStore);
     1100        return *process;
     1101    }
     1102    return createNewWebProcess(websiteDataStore);
    11141103}
    11151104
    … …  
    12971286void WebProcessPool::didReachGoodTimeToPrewarm()
    12981287{
    1299     if (!configuration().isAutomaticProcessWarmingEnabled() || !configuration().processSwapsOnNavigation())
     1288    if (!configuration().isAutomaticProcessWarmingEnabled() || !configuration().processSwapsOnNavigation() || usesSingleWebProcess())
    13001289        return;
    13011290
    … …  
    21582147    };
    21592148
     2149    if (usesSingleWebProcess())
     2150        return completionHandler(page.process(), nullptr, "Single WebProcess mode is enabled"_s);
     2151
    21602152    if (processSwapRequestedByClient == ProcessSwapRequestedByClient::Yes)
    21612153        return completionHandler(createNewProcess(), nullptr, "Process swap was requested by the client"_s);

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

    r240343 r240363  
    154154    void setLegacyCustomProtocolManagerClient(std::unique_ptr<API::CustomProtocolManagerClient>&&);
    155155
    156     void setMaximumNumberOfProcesses(unsigned); // Can only be called when there are no processes running.
    157     unsigned maximumNumberOfProcesses() const { return !m_configuration->maximumProcessCount() ? UINT_MAX : m_configuration->maximumProcessCount(); }
    158 
    159156    void setCustomWebContentServiceBundleIdentifier(const String&);
    160157    const String& customWebContentServiceBundleIdentifier() { return m_configuration->customWebContentServiceBundleIdentifier(); }
    … …  
    517514    void languageChanged();
    518515
     516    bool usesSingleWebProcess() const { return m_configuration->usesSingleWebProcess(); }
     517
    519518#if PLATFORM(IOS_FAMILY)
    520519    String cookieStorageDirectory() const;

  • trunk/Tools/ChangeLog

    r240361 r240363  
     12019-01-23  Chris Dumez  <cdumez@apple.com>
     2
     3        Deprecate API to limit the maximum number of WebProcesses
     4        https://bugs.webkit.org/show_bug.cgi?id=193725
     5        <rdar://problem/47464879>
     6
     7        Reviewed by Geoff Garen.
     8
     9        Update existing API tests to stop using deprecated API.
     10
     11        * MiniBrowser/mac/AppDelegate.m:
     12        (defaultConfiguration):
     13        * TestWebKitAPI/Tests/WebKit/UserMedia.cpp:
     14        (TestWebKitAPI::TEST):
     15        * TestWebKitAPI/Tests/WebKitCocoa/ResponsivenessTimer.mm:
     16        (TestWebKitAPI::TEST):
     17        * TestWebKitAPI/Tests/WebKitCocoa/ServiceWorkerBasic.mm:
     18        * TestWebKitAPI/Tests/WebKitCocoa/UserContentController.mm:
     19        (TEST):
     20        * TestWebKitAPI/Tests/WebKitCocoa/WKProcessPoolConfiguration.mm:
     21        (TEST):
     22
    1232019-01-23  Aakash Jain  <aakash_jain@apple.com>
    224

  • trunk/Tools/MiniBrowser/mac/AppDelegate.m

    r239855 r240363  
    101101        processConfiguration.diskCacheSpeculativeValidationEnabled = ![SettingsController shared].networkCacheSpeculativeRevalidationDisabled;
    102102        if ([SettingsController shared].perWindowWebProcessesDisabled)
    103             processConfiguration.maximumProcessCount = 1;
     103            processConfiguration.usesSingleWebProcess = YES;
    104104        if ([SettingsController shared].processSwapOnWindowOpenWithOpenerEnabled)
    105105            processConfiguration.processSwapsOnWindowOpenWithOpener = true;

  • trunk/Tools/TestWebKitAPI/Tests/WebKit/UserMedia.cpp

    r239643 r240363  
    107107{
    108108    auto context = adoptWK(WKContextCreateWithConfiguration(nullptr));
    109     WKContextSetMaximumNumberOfProcesses(context.get(), 1);
    110109
    111110    WKRetainPtr<WKPageGroupRef> pageGroup(AdoptWK, WKPageGroupCreateWithIdentifier(Util::toWK("GetUserMedia").get()));
    … …  
    132131
    133132    // Load a second page in same process.
    134     PlatformWebView webView2(context.get(), pageGroup.get());
     133    PlatformWebView webView2(webView.page());
    135134    WKPageSetPageUIClient(webView2.page(), &uiClient.base);
    136135    WKPageNavigationClientV0 navigationClient;

  • trunk/Tools/TestWebKitAPI/Tests/WebKitCocoa/ResponsivenessTimer.mm

    r235391 r240363  
    6161    auto processPoolConfiguration = adoptNS([_WKProcessPoolConfiguration new]);
    6262    auto processPool = adoptNS([[WKProcessPool alloc] _initWithConfiguration:processPoolConfiguration.get()]);
    63     [processPool _setMaximumNumberOfProcesses:1];
    6463    auto delegate = adoptNS([ResponsivenessTimerDelegate new]);
    6564

  • trunk/Tools/TestWebKitAPI/Tests/WebKitCocoa/ServiceWorkerBasic.mm

    r239534 r240363  
    971971    auto pool = configuration.processPool;
    972972    [pool _registerURLSchemeServiceWorkersCanHandle:@"sw"];
    973     [pool _setMaximumNumberOfProcesses:5];
    974973
    975974    configuration.websiteDataStore = (WKWebsiteDataStore *)WKContextGetWebsiteDataStore(context.get());
    … …  
    12501249    [newConfiguration.get().websiteDataStore _setServiceWorkerRegistrationDirectory: @"~/nonexistingfolder"];
    12511250
    1252     [newConfiguration.get().processPool _setMaximumNumberOfProcesses:1];
    1253 
    12541251    webView = adoptNS([[WKWebView alloc] initWithFrame:NSMakeRect(0, 0, 800, 600) configuration:newConfiguration.get()]);
    12551252    request = [NSURLRequest requestWithURL:[NSURL URLWithString:@"sw://host/regularPageWithoutConnection.html"]];
    … …  
    12621259
    12631260    webView = adoptNS([[WKWebView alloc] initWithFrame:NSMakeRect(0, 0, 800, 600) configuration:newConfiguration.get()]);
    1264     EXPECT_EQ(1u, webView.get().configuration.processPool._webProcessCountIgnoringPrewarmed);
     1261    EXPECT_EQ(2u, webView.get().configuration.processPool._webProcessCountIgnoringPrewarmed);
    12651262    request = [NSURLRequest requestWithURL:[NSURL URLWithString:@"sw://host/regularPageWithConnection.html"]];
    12661263    [webView loadRequest:request];
    … …  
    12691266
    12701267    // Make sure that loading the simple page did not start the service worker process.
    1271     EXPECT_EQ(1u, webView.get().configuration.processPool._webProcessCountIgnoringPrewarmed);
     1268    EXPECT_EQ(2u, webView.get().configuration.processPool._webProcessCountIgnoringPrewarmed);
    12721269
    12731270    [[configuration websiteDataStore] removeDataOfTypes:[WKWebsiteDataStore allWebsiteDataTypes] modifiedSince:[NSDate distantPast] completionHandler:^() {

  • trunk/Tools/TestWebKitAPI/Tests/WebKitCocoa/UserContentController.mm

    r237266 r240363  
    238238    RetainPtr<WKWebViewConfiguration> configuration = adoptNS([[WKWebViewConfiguration alloc] init]);
    239239    RetainPtr<_WKProcessPoolConfiguration> processPoolConfiguration = adoptNS([[_WKProcessPoolConfiguration alloc] init]);
    240     [processPoolConfiguration setMaximumProcessCount:1];
    241240    [configuration setProcessPool:[[[WKProcessPool alloc] _initWithConfiguration:processPoolConfiguration.get()] autorelease]];
    242241

  • trunk/Tools/TestWebKitAPI/Tests/WebKitCocoa/WKProcessPoolConfiguration.mm

    r238076 r240363  
    3737
    3838    [configuration setInjectedBundleURL:[NSURL fileURLWithPath:@"/path/to/injected.wkbundle"]];
    39     [configuration setMaximumProcessCount:42];
    4039    [configuration setCustomWebContentServiceBundleIdentifier:@"org.webkit.WebContent.custom"];
    4140    [configuration setIgnoreSynchronousMessagingTimeoutsForTesting:YES];
    … …  
    6665
    6766    EXPECT_TRUE([[configuration injectedBundleURL] isEqual:[copy injectedBundleURL]]);
    68     EXPECT_EQ([configuration maximumProcessCount], [copy maximumProcessCount]);
    6967    EXPECT_TRUE([[configuration customWebContentServiceBundleIdentifier] isEqual:[copy customWebContentServiceBundleIdentifier]]);
    7068    EXPECT_EQ([configuration ignoreSynchronousMessagingTimeoutsForTesting], [copy ignoreSynchronousMessagingTimeoutsForTesting]);
Note: See TracChangeset for help on using the changeset viewer.