Attachment #409076 for bug #216556

View Details Raw Unified Return to Bug 216556

| Differences between



2020-09-17  Sam Weinig  <weinig@apple.com>

        Remove runtime setting for enabling/disabling the UserTiming and ResourceTiming APIs
        https://bugs.webkit.org/show_bug.cgi?id=216556

        Reviewed by NOBODY (OOPS!).

        Remove runtime setting for enabling/disabling UserTiming and ResourceTiming 
        APIs. They have both been on for a while in WebKit2 and there aren't any
        known uses cases for disabling them. In addition to removing the setting, 
        they are now enabled in LegacyWebKit as well.

        In addition to removing UserTiming and ResourceTiming, we can also remove the
        checks for PerformanceTimelineEnabled, as that was defined entirely in terms
        of the former.

        * loader/CrossOriginPreflightChecker.cpp:
        (WebCore::CrossOriginPreflightChecker::startPreflight):
        * loader/DocumentThreadableLoader.cpp:
        (WebCore::DocumentThreadableLoader::loadRequest):
        * loader/ResourceTimingInformation.cpp:
        (WebCore::ResourceTimingInformation::addResourceTiming):
        (WebCore::ResourceTimingInformation::storeResourceTimingInitiatorInformation):
        * loader/SubresourceLoader.cpp:
        (WebCore::SubresourceLoader::reportResourceTiming):
        * loader/cache/CachedResourceLoader.cpp:
        (WebCore::CachedResourceLoader::requestResource):
        (WebCore::CachedResourceLoader::revalidateResource):
        (WebCore::CachedResourceLoader::loadResource):
        * page/Performance.idl:
        * page/PerformanceEntry.cpp:
        (WebCore::PerformanceEntry::parseEntryTypeString):
        * page/PerformanceEntry.idl:
        * page/PerformanceObserver.idl:
        * page/PerformanceObserverEntryList.idl:
        * page/PerformanceResourceTiming.idl:
        * page/RuntimeEnabledFeatures.h:
        (WebCore::RuntimeEnabledFeatures::setResourceTimingEnabled): Deleted.
        (WebCore::RuntimeEnabledFeatures::resourceTimingEnabled const): Deleted.
        (WebCore::RuntimeEnabledFeatures::setUserTimingEnabled): Deleted.
        (WebCore::RuntimeEnabledFeatures::userTimingEnabled const): Deleted.
        (WebCore::RuntimeEnabledFeatures::performanceTimelineEnabled const): Deleted.

2020-09-17  Antti Koivisto  <antti@apple.com>

        Style::Change should be enum class



    options.initiatorContext = m_loader.options().initiatorContext;

    CachedResourceRequest preflightRequest(createAccessControlPreflightRequest(m_request, m_loader.securityOrigin(), m_loader.referrer()), options);
    preflightRequest.setInitiator(m_loader.options().initiator);
        preflightRequest.setInitiator(m_loader.options().initiator);

    ASSERT(!m_resource);
    m_resource = m_loader.document().cachedResourceLoader().requestRawResource(WTFMove(preflightRequest)).value_or(nullptr);




        request.setAllowCookies(m_options.storedCredentialsPolicy == StoredCredentialsPolicy::Use);
        CachedResourceRequest newRequest(WTFMove(request), options);
        newRequest.setInitiator(m_options.initiator);
            newRequest.setInitiator(m_options.initiator);
        newRequest.setOrigin(securityOrigin());

        ASSERT(!m_resource);

    if (data)
        didReceiveData(identifier, data->data(), data->size());

    const auto* timing = response.deprecatedNetworkLoadMetricsOrNull();
    Optional<NetworkLoadMetrics> empty;
    if (!timing) {
        empty.emplace();
        timing = &empty.value();
    }
    auto resourceTiming = ResourceTiming::fromSynchronousLoad(requestURL, m_options.initiator, loadTiming, *timing, response, securityOrigin());
    if (options().initiatorContext == InitiatorContext::Worker)
        finishedTimingForWorkerLoad(resourceTiming);
    else {
        if (auto* window = document().domWindow())
            window->performance().addResourceTiming(WTFMove(resourceTiming));
                window->performance().addResourceTiming(WTFMove(resourceTiming));
        }
    }

    didFinishLoading(identifier);




void ResourceTimingInformation::addResourceTiming(CachedResource& resource, Document& document, ResourceTiming&& resourceTiming)
{
    ASSERT(RuntimeEnabledFeatures::sharedFeatures().resourceTimingEnabled());
    if (!ResourceTimingInformation::shouldAddResourceTiming(resource))
        return;



void ResourceTimingInformation::storeResourceTimingInitiatorInformation(const CachedResourceHandle<CachedResource>& resource, const AtomString& initiatorName, Frame* frame)
{
    ASSERT(RuntimeEnabledFeatures::sharedFeatures().resourceTimingEnabled());
    ASSERT(resource.get());

    if (resource->type() == CachedResource::Type::MainResource) {




void SubresourceLoader::reportResourceTiming(const NetworkLoadMetrics& networkLoadMetrics)
{
    if (!RuntimeEnabledFeatures::sharedFeatures().resourceTimingEnabled())
        return;

    if (!ResourceTimingInformation::shouldAddResourceTiming(*m_resource))
        return;





            memoryCache.resourceAccessed(*resource);

            if (document() && !resource->isLoading()) {
                auto resourceTiming = ResourceTiming::fromCache(url, request.initiatorName(), loadTiming, resource->response(), *request.origin());
                if (initiatorContext == InitiatorContext::Worker) {
                    ASSERT(is<CachedRawResource>(resource.get()));

    memoryCache.remove(resource);
    memoryCache.add(*newResource);

    m_resourceTimingInfo.storeResourceTimingInitiatorInformation(newResource, newResource->initiatorName(), frame());
        m_resourceTimingInfo.storeResourceTimingInitiatorInformation(newResource, newResource->initiatorName(), frame());

    return newResource;
}

    if (resource->allowsCaching())
        memoryCache.add(*resource);

    m_resourceTimingInfo.storeResourceTimingInitiatorInformation(resource, resource->initiatorName(), frame());
        m_resourceTimingInfo.storeResourceTimingInitiatorInformation(resource, resource->initiatorName(), frame());

    return resource;
}



    Exposed=(Window,Worker),
    GenerateIsReachable=ImplScriptExecutionContext,
] interface Performance : EventTarget {

    DOMHighResTimeStamp now();
    // FIXME: Implement 'timeOrigin'.
    // readonly attribute DOMHighResTimeStamp timeOrigin;
    // FIXME: Implement 'toJSON'.
    // [Default] object toJSON();

    // https://w3c.github.io/navigation-timing/
    readonly attribute PerformanceNavigation navigation;
    readonly attribute PerformanceTiming timing;

    // https://w3c.github.io/performance-timeline/
    PerformanceEntryList getEntries();
    PerformanceEntryList getEntriesByType(DOMString entryType);
    PerformanceEntryList getEntriesByName(DOMString name, optional DOMString entryType);

    // https://w3c.github.io/resource-timing/
    undefined clearResourceTimings();
    undefined setResourceTimingBufferSize(unsigned long maxSize);
    attribute EventHandler onresourcetimingbufferfull;

    // https://w3c.github.io/user-timing/
    MayThrowException] undefined mark(DOMString markName);
    undefined clearMarks(optional DOMString markName);
    MayThrowException] undefined measure(DOMString measureName, optional DOMString startMark, optional DOMString endMark);
    undefined clearMeasures(optional DOMString measureName);
};

typedef sequence<PerformanceEntry> PerformanceEntryList;



    if (entryType == "navigation")
        return Optional<Type>(Type::Navigation);

    if (entryType == "mark")
        return Optional<Type>(Type::Mark);
    if (entryType == "measure")
        return Optional<Type>(Type::Measure);
            return Optional<Type>(Type::Measure);
    }

    if (entryType == "resource")
        return Optional<Type>(Type::Resource);
            return Optional<Type>(Type::Resource);
    }

    if (RuntimeEnabledFeatures::sharedFeatures().paintTimingEnabled()) {
        if (entryType == "paint")

Lines 34-40 typedef double DOMHighResTimeStamp; Source/WebCore/page/PerformanceEntry.idl_sec1
- Source/WebCore/page/PerformanceEntry.idl -1 lines
34		34
35	[	35	[
36	CustomToJSObject,	36	CustomToJSObject,
37	EnabledAtRuntime=PerformanceTimeline,
38	Exposed=(Window,Worker),	37	Exposed=(Window,Worker),
39	] interface PerformanceEntry {	38	] interface PerformanceEntry {
40	readonly attribute DOMString name;	39	readonly attribute DOMString name;

Lines 27-33 Source/WebCore/page/PerformanceObserver.idl_sec1
- Source/WebCore/page/PerformanceObserver.idl -1 lines
27		27
28	[	28	[
29	CustomIsReachable,	29	CustomIsReachable,
30	EnabledAtRuntime=PerformanceTimeline,
31	Exposed=(Window,Worker),	30	Exposed=(Window,Worker),
32	ImplementationLacksVTable,	31	ImplementationLacksVTable,
33	JSCustomMarkFunction,	32	JSCustomMarkFunction,

Lines 26-32 Source/WebCore/page/PerformanceObserverEntryList.idl_sec1
- Source/WebCore/page/PerformanceObserverEntryList.idl -1 lines
26	// https://w3c.github.io/performance-timeline/	26	// https://w3c.github.io/performance-timeline/
27		27
28	[	28	[
29	EnabledAtRuntime=PerformanceTimeline,
30	Exposed=(Window,Worker),	29	Exposed=(Window,Worker),
31	ImplementationLacksVTable,	30	ImplementationLacksVTable,
32	] interface PerformanceObserverEntryList {	31	] interface PerformanceObserverEntryList {

Lines 33-39 Source/WebCore/page/PerformanceResourceTiming.idl_sec1
- Source/WebCore/page/PerformanceResourceTiming.idl -1 lines
33	typedef double DOMHighResTimeStamp;	33	typedef double DOMHighResTimeStamp;
34		34
35	[	35	[
36	EnabledAtRuntime=ResourceTiming,
37	Exposed=(Window,Worker),	36	Exposed=(Window,Worker),
38	] interface PerformanceResourceTiming : PerformanceEntry {	37	] interface PerformanceResourceTiming : PerformanceEntry {
39	readonly attribute DOMString initiatorType;	38	readonly attribute DOMString initiatorType;



class RuntimeEnabledFeatures {
    WTF_MAKE_NONCOPYABLE(RuntimeEnabledFeatures);
public:
    void setResourceTimingEnabled(bool isEnabled) { m_isResourceTimingEnabled = isEnabled; }
    bool resourceTimingEnabled() const { return m_isResourceTimingEnabled; }

    void setUserTimingEnabled(bool isEnabled) { m_isUserTimingEnabled = isEnabled; }
    bool userTimingEnabled() const { return m_isUserTimingEnabled; }

    void setPaintTimingEnabled(bool isEnabled) { m_isPaintTimingEnabled = isEnabled; }
    bool paintTimingEnabled() const { return m_isPaintTimingEnabled; }

    bool performanceTimelineEnabled() const { return resourceTimingEnabled() || userTimingEnabled(); }

    void setMenuItemElementEnabled(bool isEnabled) { m_isMenuItemElementEnabled = isEnabled; }
    bool menuItemElementEnabled() const { return m_isMenuItemElementEnabled; }



    bool m_areModernMediaControlsEnabled { false };
    bool m_isPaintTimingEnabled { false };
    bool m_isResourceTimingEnabled { false };
    bool m_isUserTimingEnabled { false };
    bool m_isMenuItemElementEnabled { false };
    bool m_isDirectoryUploadEnabled { false };
    bool m_isCustomPasteboardDataEnabled { false };



2020-09-17  Sam Weinig  <weinig@apple.com>

        Remove runtime setting for enabling/disabling the UserTiming and ResourceTiming APIs
        https://bugs.webkit.org/show_bug.cgi?id=216556

        Reviewed by NOBODY (OOPS!).

        Remove runtime setting for enabling/disabling UserTiming and ResourceTiming 
        APIs. They have both been on for a while in WebKit2 and there aren't any
        known uses cases for disabling them. In addition to removing the setting, 
        they are now enabled in LegacyWebKit as well.

        * Shared/WebPreferences.yaml:
        * UIProcess/API/C/WKPreferences.cpp:
        (WKPreferencesSetUserTimingEnabled):
        (WKPreferencesGetUserTimingEnabled):
        (WKPreferencesSetResourceTimingEnabled):
        (WKPreferencesGetResourceTimingEnabled):
        * UIProcess/API/C/WKPreferencesRefPrivate.h:

2020-09-17  Sam Weinig  <weinig@apple.com>

        We shouldn't need to specify a category for preferences now that they are split into separate files



  humanReadableDescription: "Use modern media controls look"
  webcoreBinding: RuntimeEnabledFeatures

ResourceTimingEnabled:
  type: bool
  defaultValue: true
  humanReadableName: "Resource Timing"
  humanReadableDescription: "Enable ResourceTiming API"
  webcoreBinding: RuntimeEnabledFeatures

UserTimingEnabled:
  type: bool
  defaultValue: true
  humanReadableName: "User Timing"
  humanReadableDescription: "Enable UserTiming API"
  webcoreBinding: RuntimeEnabledFeatures

BeaconAPIEnabled:
  type: bool
  defaultValue: true



    return toImpl(preferencesRef)->menuItemElementEnabled();
}

void WKPreferencesSetUserTimingEnabled(WKPreferencesRef preferencesRef, bool flag)
{
    toImpl(preferencesRef)->setUserTimingEnabled(flag);
}

bool WKPreferencesGetUserTimingEnabled(WKPreferencesRef preferencesRef)
{
    return toImpl(preferencesRef)->userTimingEnabled();
}

void WKPreferencesSetPaintTimingEnabled(WKPreferencesRef preferencesRef, bool flag)
{
    toImpl(preferencesRef)->setPaintTimingEnabled(flag);

    return toImpl(preferencesRef)->paintTimingEnabled();
}

void WKPreferencesSetResourceTimingEnabled(WKPreferencesRef preferencesRef, bool flag)
{
    toImpl(preferencesRef)->setResourceTimingEnabled(flag);
}

bool WKPreferencesGetResourceTimingEnabled(WKPreferencesRef preferencesRef)
{
    return toImpl(preferencesRef)->resourceTimingEnabled();
}

void WKPreferencesSetIsNSURLSessionWebSocketEnabled(WKPreferencesRef preferencesRef, bool flag)
{

{
    return true;
}

void WKPreferencesSetUserTimingEnabled(WKPreferencesRef, bool)
{
}

bool WKPreferencesGetUserTimingEnabled(WKPreferencesRef)
{
    return true;
}

void WKPreferencesSetResourceTimingEnabled(WKPreferencesRef, bool)
{
}

bool WKPreferencesGetResourceTimingEnabled(WKPreferencesRef)
{
    return true;
}



WK_EXPORT bool WKPreferencesGetWebShareEnabled(WKPreferencesRef);

// Defaults to false
WK_EXPORT void WKPreferencesSetUserTimingEnabled(WKPreferencesRef, bool flag);
WK_EXPORT bool WKPreferencesGetUserTimingEnabled(WKPreferencesRef);

// Defaults to false
WK_EXPORT void WKPreferencesSetPaintTimingEnabled(WKPreferencesRef, bool flag);
WK_EXPORT bool WKPreferencesGetPaintTimingEnabled(WKPreferencesRef);

// Defaults to false
WK_EXPORT void WKPreferencesSetResourceTimingEnabled(WKPreferencesRef, bool flag);
WK_EXPORT bool WKPreferencesGetResourceTimingEnabled(WKPreferencesRef);

// Defaults to false
WK_EXPORT void WKPreferencesSetFetchAPIKeepAliveEnabled(WKPreferencesRef, bool flag);
WK_EXPORT bool WKPreferencesGetFetchAPIKeepAliveEnabled(WKPreferencesRef);


WK_EXPORT bool WKPreferencesGetFetchAPIEnabled(WKPreferencesRef) WK_C_API_DEPRECATED;
WK_EXPORT void WKPreferencesSetIsSecureContextAttributeEnabled(WKPreferencesRef, bool) WK_C_API_DEPRECATED;
WK_EXPORT bool WKPreferencesGetIsSecureContextAttributeEnabled(WKPreferencesRef) WK_C_API_DEPRECATED;
WK_EXPORT void WKPreferencesSetUserTimingEnabled(WKPreferencesRef, bool) WK_C_API_DEPRECATED;
WK_EXPORT bool WKPreferencesGetUserTimingEnabled(WKPreferencesRef) WK_C_API_DEPRECATED;
WK_EXPORT void WKPreferencesSetResourceTimingEnabled(WKPreferencesRef, bool) WK_C_API_DEPRECATED;
WK_EXPORT bool WKPreferencesGetResourceTimingEnabled(WKPreferencesRef) WK_C_API_DEPRECATED;

#ifdef __cplusplus
}



2020-09-17  Sam Weinig  <weinig@apple.com>

        Remove runtime setting for enabling/disabling the UserTiming and ResourceTiming APIs
        https://bugs.webkit.org/show_bug.cgi?id=216556

        Reviewed by NOBODY (OOPS!).

        Remove runtime setting for enabling/disabling UserTiming and ResourceTiming 
        APIs. They have both been on for a while in WebKit2 and there aren't any
        known uses cases for disabling them. In addition to removing the setting, 
        they are now enabled in LegacyWebKit as well.

        * WebView/WebPreferences.mm:
        (+[WebPreferences initialize]):
        (-[WebPreferences setUserTimingEnabled:]):
        (-[WebPreferences userTimingEnabled]):
        (-[WebPreferences setResourceTimingEnabled:]):
        (-[WebPreferences resourceTimingEnabled]):
        * WebView/WebPreferencesPrivate.h:
        * WebView/WebView.mm:
        (-[WebView _preferencesChanged:]):

2020-09-17  Antoine Quint  <graouts@webkit.org>

        Remove the legacy animation code



#if ENABLE(INTERSECTION_OBSERVER)
        @NO, WebKitIntersectionObserverEnabledPreferenceKey,
#endif
        @NO, WebKitUserTimingEnabledPreferenceKey,
        @NO, WebKitResourceTimingEnabledPreferenceKey,
        @NO, WebKitMediaUserGestureInheritsFromDocument,
        @YES, WebKitLegacyEncryptedMediaAPIEnabledKey,
        @NO, WebKitEncryptedMediaAPIEnabledKey,

    [self _setBoolValue:flag forKey:WebKitMenuItemElementEnabledPreferenceKey];
}

- (BOOL)userTimingEnabled
{
    return [self _boolValueForKey:WebKitUserTimingEnabledPreferenceKey];
}

- (void)setUserTimingEnabled:(BOOL)flag
{
    [self _setBoolValue:flag forKey:WebKitUserTimingEnabledPreferenceKey];
}

- (BOOL)resourceTimingEnabled
{
    return [self _boolValueForKey:WebKitResourceTimingEnabledPreferenceKey];
}

- (void)setResourceTimingEnabled:(BOOL)flag
{
    [self _setBoolValue:flag forKey:WebKitResourceTimingEnabledPreferenceKey];
}

- (BOOL)mediaUserGestureInheritsFromDocument
{
    return [self _boolValueForKey:WebKitMediaUserGestureInheritsFromDocument];

// The preferences in this category are deprecated and have no effect. They should
// be removed when it is considered safe to do so.

- (void)setUserTimingEnabled:(BOOL)flag
{
}

- (BOOL)userTimingEnabled
{
    return YES;
}

- (void)setResourceTimingEnabled:(BOOL)flag
{
}

- (BOOL)resourceTimingEnabled
{
    return YES;
}

- (void)setCSSShadowPartsEnabled:(BOOL)flag
{
}



    settings.setIntersectionObserverEnabled(preferences.intersectionObserverEnabled);
#endif

    RuntimeEnabledFeatures::sharedFeatures().setUserTimingEnabled(preferences.userTimingEnabled);
    RuntimeEnabledFeatures::sharedFeatures().setResourceTimingEnabled(preferences.resourceTimingEnabled);
    settings.setLinkPreloadEnabled(preferences.linkPreloadEnabled);
    settings.setMediaPreloadingEnabled(preferences.mediaPreloadingEnabled);
    RuntimeEnabledFeatures::sharedFeatures().setDirectoryUploadEnabled([preferences directoryUploadEnabled]);



2020-09-17  Sam Weinig  <weinig@apple.com>

        Remove runtime setting for enabling/disabling the UserTiming and ResourceTiming APIs
        https://bugs.webkit.org/show_bug.cgi?id=216556

        Reviewed by NOBODY (OOPS!).

        Remove runtime setting for enabling/disabling UserTiming and ResourceTiming 
        APIs. They have both been on for a while in WebKit2 and there aren't any
        known uses cases for disabling them. In addition to removing the setting, 
        they are now enabled in LegacyWebKit as well.

        * WebPreferences.cpp:
        (WebPreferences::initializeDefaultSettings):
        (WebPreferences::setUserTimingEnabled):
        (WebPreferences::userTimingEnabled):
        (WebPreferences::setResourceTimingEnabled):
        (WebPreferences::resourceTimingEnabled):
        * WebView.cpp:
        (WebView::notifyPreferencesChanged):

2020-09-17  Antoine Quint  <graouts@webkit.org>

        Remove the legacy animation code




    CFDictionaryAddValue(defaults, CFSTR(WebKitCSSCustomPropertiesAndValuesEnabledPreferenceKey), kCFBooleanFalse);

    CFDictionaryAddValue(defaults, CFSTR(WebKitUserTimingEnabledPreferenceKey), kCFBooleanFalse);

    CFDictionaryAddValue(defaults, CFSTR(WebKitResourceTimingEnabledPreferenceKey), kCFBooleanFalse);

    CFDictionaryAddValue(defaults, CFSTR(WebKitLinkPreloadEnabledPreferenceKey), kCFBooleanFalse);

    CFDictionaryAddValue(defaults, CFSTR(WebKitMediaPreloadingEnabledPreferenceKey), kCFBooleanFalse);

    return S_OK;
}
    
HRESULT WebPreferences::setUserTimingEnabled(BOOL)
{
    setBoolValue(WebKitUserTimingEnabledPreferenceKey, enabled);
    return S_OK;
}


{
    if (!enabled)
        return E_POINTER;
    *enabled = true;
    return S_OK;
}

HRESULT WebPreferences::setResourceTimingEnabled(BOOL)
{
    setBoolValue(WebKitResourceTimingEnabledPreferenceKey, enabled);
    return S_OK;
}


{
    if (!enabled)
        return E_POINTER;
    *enabled = true;
    return S_OK;
}




        return hr;
    settings.setCSSCustomPropertiesAndValuesEnabled(!!enabled);

    hr = prefsPrivate->userTimingEnabled(&enabled);
    if (FAILED(hr))
        return hr;
    RuntimeEnabledFeatures::sharedFeatures().setUserTimingEnabled(!!enabled);

    hr = prefsPrivate->resourceTimingEnabled(&enabled);
    if (FAILED(hr))
        return hr;
    RuntimeEnabledFeatures::sharedFeatures().setResourceTimingEnabled(!!enabled);

    hr = prefsPrivate->linkPreloadEnabled(&enabled);
    if (FAILED(hr))
        return hr;



2020-09-17  Sam Weinig  <weinig@apple.com>

        Remove runtime setting for enabling/disabling the UserTiming and ResourceTiming APIs
        https://bugs.webkit.org/show_bug.cgi?id=216556

        Reviewed by NOBODY (OOPS!).

        Remove runtime setting for enabling/disabling UserTiming and ResourceTiming 
        APIs. They have both been on for a while in WebKit2 and there aren't any
        known uses cases for disabling them. In addition to removing the setting, 
        they are now enabled in LegacyWebKit as well.

        * DumpRenderTree/mac/DumpRenderTree.mm:
        (resetWebPreferencesToConsistentValues):
        * DumpRenderTree/win/DumpRenderTree.cpp:
        (resetWebPreferencesToConsistentValues):
        * WebKitTestRunner/TestController.cpp:
        (WTR::TestController::resetPreferencesToConsistentValues):

2020-09-17  Víctor Manuel Jáquez Leal  <vjaquez@igalia.com>

        [Flatpak SDK] bwrap: add pipewire socket as bind mount



    [preferences setLargeImageAsyncDecodingEnabled:NO];

    [preferences setModernMediaControlsEnabled:YES];
    [preferences setResourceTimingEnabled:YES];
    [preferences setUserTimingEnabled:YES];

    [preferences setCacheAPIEnabled:NO];
    preferences.mediaCapabilitiesEnabled = YES;




    preferences->setFontSmoothing(FontSmoothingTypeStandard);

    prefsPrivate->setResourceTimingEnabled(TRUE);
    prefsPrivate->setUserTimingEnabled(TRUE);
    prefsPrivate->setDataTransferItemsEnabled(TRUE);
    prefsPrivate->clearNetworkLoaderSession();




    WKPreferencesSetIsNSURLSessionWebSocketEnabled(preferences, false);

    WKPreferencesSetFetchAPIKeepAliveEnabled(preferences, true);
    WKPreferencesSetResourceTimingEnabled(preferences, true);
    WKPreferencesSetUserTimingEnabled(preferences, true);
    WKPreferencesSetMediaPreloadingEnabled(preferences, true);
    WKPreferencesSetExposeSpeakersEnabled(preferences, true);
    WKPreferencesSetMediaPlaybackAllowsInline(preferences, true);

Return to Bug 216556

Lines 116-123 void CrossOriginPreflightChecker::startP Source/WebCore/loader/CrossOriginPreflightChecker.cpp_sec1
- Source/WebCore/loader/CrossOriginPreflightChecker.cpp -2 / +1 lines
116	options.initiatorContext = m_loader.options().initiatorContext;	116	options.initiatorContext = m_loader.options().initiatorContext;
117		117
118	CachedResourceRequest preflightRequest(createAccessControlPreflightRequest(m_request, m_loader.securityOrigin(), m_loader.referrer()), options);	118	CachedResourceRequest preflightRequest(createAccessControlPreflightRequest(m_request, m_loader.securityOrigin(), m_loader.referrer()), options);
119	if (RuntimeEnabledFeatures::sharedFeatures().resourceTimingEnabled())	119	preflightRequest.setInitiator(m_loader.options().initiator);
120	preflightRequest.setInitiator(m_loader.options().initiator);
121		120
122	ASSERT(!m_resource);	121	ASSERT(!m_resource);
123	m_resource = m_loader.document().cachedResourceLoader().requestRawResource(WTFMove(preflightRequest)).value_or(nullptr);	122	m_resource = m_loader.document().cachedResourceLoader().requestRawResource(WTFMove(preflightRequest)).value_or(nullptr);

Lines 865-873 void SubresourceLoader::releaseResources Source/WebCore/loader/SubresourceLoader.cpp_sec1
- Source/WebCore/loader/SubresourceLoader.cpp -3 lines
865		865
866	void SubresourceLoader::reportResourceTiming(const NetworkLoadMetrics& networkLoadMetrics)	866	void SubresourceLoader::reportResourceTiming(const NetworkLoadMetrics& networkLoadMetrics)
867	{	867	{
868	if (!RuntimeEnabledFeatures::sharedFeatures().resourceTimingEnabled())
869	return;
870
871	if (!ResourceTimingInformation::shouldAddResourceTiming(*m_resource))	868	if (!ResourceTimingInformation::shouldAddResourceTiming(*m_resource))
872	return;	869	return;
873		870

Lines 958-964 ResourceErrorOr<CachedResourceHandle<Cac Source/WebCore/loader/cache/CachedResourceLoader.cpp_sec1
- Source/WebCore/loader/cache/CachedResourceLoader.cpp -5 / +3 lines
958		958
959	memoryCache.resourceAccessed(*resource);	959	memoryCache.resourceAccessed(*resource);
960		960
961	if (RuntimeEnabledFeatures::sharedFeatures().resourceTimingEnabled() && document() && !resource->isLoading()) {	961	if (document() && !resource->isLoading()) {
962	auto resourceTiming = ResourceTiming::fromCache(url, request.initiatorName(), loadTiming, resource->response(), *request.origin());	962	auto resourceTiming = ResourceTiming::fromCache(url, request.initiatorName(), loadTiming, resource->response(), *request.origin());
963	if (initiatorContext == InitiatorContext::Worker) {	963	if (initiatorContext == InitiatorContext::Worker) {
964	ASSERT(is<CachedRawResource>(resource.get()));	964	ASSERT(is<CachedRawResource>(resource.get()));
Lines 1042-1049 CachedResourceHandle<CachedResource> Cac Source/WebCore/loader/cache/CachedResourceLoader.cpp_sec2
1042	memoryCache.remove(resource);	1042	memoryCache.remove(resource);
1043	memoryCache.add(*newResource);	1043	memoryCache.add(*newResource);
1044		1044
1045	if (RuntimeEnabledFeatures::sharedFeatures().resourceTimingEnabled())	1045	m_resourceTimingInfo.storeResourceTimingInitiatorInformation(newResource, newResource->initiatorName(), frame());
1046	m_resourceTimingInfo.storeResourceTimingInitiatorInformation(newResource, newResource->initiatorName(), frame());
1047		1046
1048	return newResource;	1047	return newResource;
1049	}	1048	}
Lines 1061-1068 CachedResourceHandle<CachedResource> Cac Source/WebCore/loader/cache/CachedResourceLoader.cpp_sec3
1061	if (resource->allowsCaching())	1060	if (resource->allowsCaching())
1062	memoryCache.add(*resource);	1061	memoryCache.add(*resource);
1063		1062
1064	if (RuntimeEnabledFeatures::sharedFeatures().resourceTimingEnabled())	1063	m_resourceTimingInfo.storeResourceTimingInitiatorInformation(resource, resource->initiatorName(), frame());
1065	m_resourceTimingInfo.storeResourceTimingInitiatorInformation(resource, resource->initiatorName(), frame());
1066		1064
1067	return resource;	1065	return resource;
1068	}	1066	}

Lines 1689-1704 bool WKPreferencesGetMenuItemElementEnab Source/WebKit/UIProcess/API/C/WKPreferences.cpp_sec1
- Source/WebKit/UIProcess/API/C/WKPreferences.cpp -19 / +18 lines
1689	return toImpl(preferencesRef)->menuItemElementEnabled();	1689	return toImpl(preferencesRef)->menuItemElementEnabled();
1690	}	1690	}
1691		1691
1692	void WKPreferencesSetUserTimingEnabled(WKPreferencesRef preferencesRef, bool flag)
1693	{
1694	toImpl(preferencesRef)->setUserTimingEnabled(flag);
1695	}
1696
1697	bool WKPreferencesGetUserTimingEnabled(WKPreferencesRef preferencesRef)
1698	{
1699	return toImpl(preferencesRef)->userTimingEnabled();
1700	}
1701
1702	void WKPreferencesSetPaintTimingEnabled(WKPreferencesRef preferencesRef, bool flag)	1692	void WKPreferencesSetPaintTimingEnabled(WKPreferencesRef preferencesRef, bool flag)
1703	{	1693	{
1704	toImpl(preferencesRef)->setPaintTimingEnabled(flag);	1694	toImpl(preferencesRef)->setPaintTimingEnabled(flag);
Lines 1709-1723 bool WKPreferencesGetPaintTimingEnabled( Source/WebKit/UIProcess/API/C/WKPreferences.cpp_sec2
1709	return toImpl(preferencesRef)->paintTimingEnabled();	1699	return toImpl(preferencesRef)->paintTimingEnabled();
1710	}	1700	}
1711		1701
1712	void WKPreferencesSetResourceTimingEnabled(WKPreferencesRef preferencesRef, bool flag)
1713	{
1714	toImpl(preferencesRef)->setResourceTimingEnabled(flag);
1715	}
1716
1717	bool WKPreferencesGetResourceTimingEnabled(WKPreferencesRef preferencesRef)
1718	{
1719	return toImpl(preferencesRef)->resourceTimingEnabled();
1720	}
1721		1702
1722	void WKPreferencesSetIsNSURLSessionWebSocketEnabled(WKPreferencesRef preferencesRef, bool flag)	1703	void WKPreferencesSetIsNSURLSessionWebSocketEnabled(WKPreferencesRef preferencesRef, bool flag)
1723	{	1704	{
Lines 2224-2226 bool WKPreferencesGetIsSecureContextAttr Source/WebKit/UIProcess/API/C/WKPreferences.cpp_sec3
2224	{	2205	{
2225	return true;	2206	return true;
2226	}	2207	}
		2208
		2209	void WKPreferencesSetUserTimingEnabled(WKPreferencesRef, bool)
		2210	{
		2211	}
		2212
		2213	bool WKPreferencesGetUserTimingEnabled(WKPreferencesRef)
		2214	{
		2215	return true;
		2216	}
		2217
		2218	void WKPreferencesSetResourceTimingEnabled(WKPreferencesRef, bool)
		2219	{
		2220	}
		2221
		2222	bool WKPreferencesGetResourceTimingEnabled(WKPreferencesRef)
		2223	{
		2224	return true;
		2225	}

Lines 461-478 WK_EXPORT void WKPreferencesSetWebShareE Source/WebKit/UIProcess/API/C/WKPreferencesRefPrivate.h_sec1
- Source/WebKit/UIProcess/API/C/WKPreferencesRefPrivate.h -8 / +4 lines
461	WK_EXPORT bool WKPreferencesGetWebShareEnabled(WKPreferencesRef);	461	WK_EXPORT bool WKPreferencesGetWebShareEnabled(WKPreferencesRef);
462		462
463	// Defaults to false	463	// Defaults to false
464	WK_EXPORT void WKPreferencesSetUserTimingEnabled(WKPreferencesRef, bool flag);
465	WK_EXPORT bool WKPreferencesGetUserTimingEnabled(WKPreferencesRef);
466
467	// Defaults to false
468	WK_EXPORT void WKPreferencesSetPaintTimingEnabled(WKPreferencesRef, bool flag);	464	WK_EXPORT void WKPreferencesSetPaintTimingEnabled(WKPreferencesRef, bool flag);
469	WK_EXPORT bool WKPreferencesGetPaintTimingEnabled(WKPreferencesRef);	465	WK_EXPORT bool WKPreferencesGetPaintTimingEnabled(WKPreferencesRef);
470		466
471	// Defaults to false	467	// Defaults to false
472	WK_EXPORT void WKPreferencesSetResourceTimingEnabled(WKPreferencesRef, bool flag);
473	WK_EXPORT bool WKPreferencesGetResourceTimingEnabled(WKPreferencesRef);
474
475	// Defaults to false
476	WK_EXPORT void WKPreferencesSetFetchAPIKeepAliveEnabled(WKPreferencesRef, bool flag);	468	WK_EXPORT void WKPreferencesSetFetchAPIKeepAliveEnabled(WKPreferencesRef, bool flag);
477	WK_EXPORT bool WKPreferencesGetFetchAPIKeepAliveEnabled(WKPreferencesRef);	469	WK_EXPORT bool WKPreferencesGetFetchAPIKeepAliveEnabled(WKPreferencesRef);
478		470
Lines 595-600 WK_EXPORT void WKPreferencesSetFetchAPIE Source/WebKit/UIProcess/API/C/WKPreferencesRefPrivate.h_sec2
595	WK_EXPORT bool WKPreferencesGetFetchAPIEnabled(WKPreferencesRef) WK_C_API_DEPRECATED;	587	WK_EXPORT bool WKPreferencesGetFetchAPIEnabled(WKPreferencesRef) WK_C_API_DEPRECATED;
596	WK_EXPORT void WKPreferencesSetIsSecureContextAttributeEnabled(WKPreferencesRef, bool) WK_C_API_DEPRECATED;	588	WK_EXPORT void WKPreferencesSetIsSecureContextAttributeEnabled(WKPreferencesRef, bool) WK_C_API_DEPRECATED;
597	WK_EXPORT bool WKPreferencesGetIsSecureContextAttributeEnabled(WKPreferencesRef) WK_C_API_DEPRECATED;	589	WK_EXPORT bool WKPreferencesGetIsSecureContextAttributeEnabled(WKPreferencesRef) WK_C_API_DEPRECATED;
		590	WK_EXPORT void WKPreferencesSetUserTimingEnabled(WKPreferencesRef, bool) WK_C_API_DEPRECATED;
		591	WK_EXPORT bool WKPreferencesGetUserTimingEnabled(WKPreferencesRef) WK_C_API_DEPRECATED;
		592	WK_EXPORT void WKPreferencesSetResourceTimingEnabled(WKPreferencesRef, bool) WK_C_API_DEPRECATED;
		593	WK_EXPORT bool WKPreferencesGetResourceTimingEnabled(WKPreferencesRef) WK_C_API_DEPRECATED;
598		594
599	#ifdef __cplusplus	595	#ifdef __cplusplus
600	}	596	}

Lines 1-3 Source/WebCore/ChangeLog_sec1
- Source/WebCore/ChangeLog +43 lines
		1	2020-09-17 Sam Weinig <weinig@apple.com>
		2
		3	Remove runtime setting for enabling/disabling the UserTiming and ResourceTiming APIs
		4	https://bugs.webkit.org/show_bug.cgi?id=216556
		5
		6	Reviewed by NOBODY (OOPS!).
		7
		8	Remove runtime setting for enabling/disabling UserTiming and ResourceTiming
		9	APIs. They have both been on for a while in WebKit2 and there aren't any
		10	known uses cases for disabling them. In addition to removing the setting,
		11	they are now enabled in LegacyWebKit as well.
		12
		13	In addition to removing UserTiming and ResourceTiming, we can also remove the
		14	checks for PerformanceTimelineEnabled, as that was defined entirely in terms
		15	of the former.
		16
		17	* loader/CrossOriginPreflightChecker.cpp:
		18	(WebCore::CrossOriginPreflightChecker::startPreflight):
		19	* loader/DocumentThreadableLoader.cpp:
		20	(WebCore::DocumentThreadableLoader::loadRequest):
		21	* loader/ResourceTimingInformation.cpp:
		22	(WebCore::ResourceTimingInformation::addResourceTiming):
		23	(WebCore::ResourceTimingInformation::storeResourceTimingInitiatorInformation):
		24	* loader/SubresourceLoader.cpp:
		25	(WebCore::SubresourceLoader::reportResourceTiming):
		26	* loader/cache/CachedResourceLoader.cpp:
		27	(WebCore::CachedResourceLoader::requestResource):
		28	(WebCore::CachedResourceLoader::revalidateResource):
		29	(WebCore::CachedResourceLoader::loadResource):
		30	* page/Performance.idl:
		31	* page/PerformanceEntry.cpp:
		32	(WebCore::PerformanceEntry::parseEntryTypeString):
		33	* page/PerformanceEntry.idl:
		34	* page/PerformanceObserver.idl:
		35	* page/PerformanceObserverEntryList.idl:
		36	* page/PerformanceResourceTiming.idl:
		37	* page/RuntimeEnabledFeatures.h:
		38	(WebCore::RuntimeEnabledFeatures::setResourceTimingEnabled): Deleted.
		39	(WebCore::RuntimeEnabledFeatures::resourceTimingEnabled const): Deleted.
		40	(WebCore::RuntimeEnabledFeatures::setUserTimingEnabled): Deleted.
		41	(WebCore::RuntimeEnabledFeatures::userTimingEnabled const): Deleted.
		42	(WebCore::RuntimeEnabledFeatures::performanceTimelineEnabled const): Deleted.
		43
1	2020-09-17 Antti Koivisto <antti@apple.com>	44	2020-09-17 Antti Koivisto <antti@apple.com>
2		45
3	Style::Change should be enum class	46	Style::Change should be enum class

Lines 548-555 void DocumentThreadableLoader::loadReque Source/WebCore/loader/DocumentThreadableLoader.cpp_sec1
- Source/WebCore/loader/DocumentThreadableLoader.cpp -16 / +13 lines
548		548
549	request.setAllowCookies(m_options.storedCredentialsPolicy == StoredCredentialsPolicy::Use);	549	request.setAllowCookies(m_options.storedCredentialsPolicy == StoredCredentialsPolicy::Use);
550	CachedResourceRequest newRequest(WTFMove(request), options);	550	CachedResourceRequest newRequest(WTFMove(request), options);
551	if (RuntimeEnabledFeatures::sharedFeatures().resourceTimingEnabled())	551	newRequest.setInitiator(m_options.initiator);
552	newRequest.setInitiator(m_options.initiator);
553	newRequest.setOrigin(securityOrigin());	552	newRequest.setOrigin(securityOrigin());
554		553
555	ASSERT(!m_resource);	554	ASSERT(!m_resource);
Lines 639-658 void DocumentThreadableLoader::loadReque Source/WebCore/loader/DocumentThreadableLoader.cpp_sec2
639	if (data)	638	if (data)
640	didReceiveData(identifier, data->data(), data->size());	639	didReceiveData(identifier, data->data(), data->size());
641		640
642	if (RuntimeEnabledFeatures::sharedFeatures().resourceTimingEnabled()) {	641	const auto* timing = response.deprecatedNetworkLoadMetricsOrNull();
643	const auto* timing = response.deprecatedNetworkLoadMetricsOrNull();	642	Optional<NetworkLoadMetrics> empty;
644	Optional<NetworkLoadMetrics> empty;	643	if (!timing) {
645	if (!timing) {	644	empty.emplace();
646	empty.emplace();	645	timing = &empty.value();
647	timing = &empty.value();	646	}
648	}	647	auto resourceTiming = ResourceTiming::fromSynchronousLoad(requestURL, m_options.initiator, loadTiming, *timing, response, securityOrigin());
649	auto resourceTiming = ResourceTiming::fromSynchronousLoad(requestURL, m_options.initiator, loadTiming, *timing, response, securityOrigin());	648	if (options().initiatorContext == InitiatorContext::Worker)
650	if (options().initiatorContext == InitiatorContext::Worker)	649	finishedTimingForWorkerLoad(resourceTiming);
651	finishedTimingForWorkerLoad(resourceTiming);	650	else {
652	else {	651	if (auto* window = document().domWindow())
653	if (auto* window = document().domWindow())	652	window->performance().addResourceTiming(WTFMove(resourceTiming));
654	window->performance().addResourceTiming(WTFMove(resourceTiming));
655	}
656	}	653	}
657		654
658	didFinishLoading(identifier);	655	didFinishLoading(identifier);

Lines 58-64 bool ResourceTimingInformation::shouldAd Source/WebCore/loader/ResourceTimingInformation.cpp_sec1
- Source/WebCore/loader/ResourceTimingInformation.cpp -2 lines
58		58
59	void ResourceTimingInformation::addResourceTiming(CachedResource& resource, Document& document, ResourceTiming&& resourceTiming)	59	void ResourceTimingInformation::addResourceTiming(CachedResource& resource, Document& document, ResourceTiming&& resourceTiming)
60	{	60	{
61	ASSERT(RuntimeEnabledFeatures::sharedFeatures().resourceTimingEnabled());
62	if (!ResourceTimingInformation::shouldAddResourceTiming(resource))	61	if (!ResourceTimingInformation::shouldAddResourceTiming(resource))
63	return;	62	return;
64		63
Lines 89-95 void ResourceTimingInformation::addResou Source/WebCore/loader/ResourceTimingInformation.cpp_sec2
89		88
90	void ResourceTimingInformation::storeResourceTimingInitiatorInformation(const CachedResourceHandle<CachedResource>& resource, const AtomString& initiatorName, Frame* frame)	89	void ResourceTimingInformation::storeResourceTimingInitiatorInformation(const CachedResourceHandle<CachedResource>& resource, const AtomString& initiatorName, Frame* frame)
91	{	90	{
92	ASSERT(RuntimeEnabledFeatures::sharedFeatures().resourceTimingEnabled());
93	ASSERT(resource.get());	91	ASSERT(resource.get());
94		92
95	if (resource->type() == CachedResource::Type::MainResource) {	93	if (resource->type() == CachedResource::Type::MainResource) {

Lines 37-64 typedef double DOMHighResTimeStamp; Source/WebCore/page/Performance.idl_sec1
- Source/WebCore/page/Performance.idl -11 / +14 lines
37	Exposed=(Window,Worker),	37	Exposed=(Window,Worker),
38	GenerateIsReachable=ImplScriptExecutionContext,	38	GenerateIsReachable=ImplScriptExecutionContext,
39	] interface Performance : EventTarget {	39	] interface Performance : EventTarget {
40
41	DOMHighResTimeStamp now();	40	DOMHighResTimeStamp now();
		41	// FIXME: Implement 'timeOrigin'.
		42	// readonly attribute DOMHighResTimeStamp timeOrigin;
		43	// FIXME: Implement 'toJSON'.
		44	// [Default] object toJSON();
42		45
43	// https://w3c.github.io/navigation-timing/	46	// https://w3c.github.io/navigation-timing/
44	readonly attribute PerformanceNavigation navigation;	47	readonly attribute PerformanceNavigation navigation;
45	readonly attribute PerformanceTiming timing;	48	readonly attribute PerformanceTiming timing;
46		49
47	// https://w3c.github.io/performance-timeline/	50	// https://w3c.github.io/performance-timeline/
48	[EnabledAtRuntime=PerformanceTimeline] PerformanceEntryList getEntries();	51	PerformanceEntryList getEntries();
49	[EnabledAtRuntime=PerformanceTimeline] PerformanceEntryList getEntriesByType(DOMString entryType);	52	PerformanceEntryList getEntriesByType(DOMString entryType);
50	[EnabledAtRuntime=PerformanceTimeline] PerformanceEntryList getEntriesByName(DOMString name, optional DOMString entryType);	53	PerformanceEntryList getEntriesByName(DOMString name, optional DOMString entryType);
51		54
52	// https://w3c.github.io/resource-timing/	55	// https://w3c.github.io/resource-timing/
53	[EnabledAtRuntime=ResourceTiming] undefined clearResourceTimings();	56	undefined clearResourceTimings();
54	[EnabledAtRuntime=ResourceTiming] undefined setResourceTimingBufferSize(unsigned long maxSize);	57	undefined setResourceTimingBufferSize(unsigned long maxSize);
55	[EnabledAtRuntime=ResourceTiming] attribute EventHandler onresourcetimingbufferfull;	58	attribute EventHandler onresourcetimingbufferfull;
56		59
57	// https://w3c.github.io/user-timing/	60	// https://w3c.github.io/user-timing/
58	[EnabledAtRuntime=UserTiming, MayThrowException] undefined mark(DOMString markName);	61	MayThrowException] undefined mark(DOMString markName);
59	[EnabledAtRuntime=UserTiming] undefined clearMarks(optional DOMString markName);	62	undefined clearMarks(optional DOMString markName);
60	[EnabledAtRuntime=UserTiming, MayThrowException] undefined measure(DOMString measureName, optional DOMString startMark, optional DOMString endMark);	63	MayThrowException] undefined measure(DOMString measureName, optional DOMString startMark, optional DOMString endMark);
61	[EnabledAtRuntime=UserTiming] undefined clearMeasures(optional DOMString measureName);	64	undefined clearMeasures(optional DOMString measureName);
62	};	65	};
63		66
64	typedef sequence<PerformanceEntry> PerformanceEntryList;	67	typedef sequence<PerformanceEntry> PerformanceEntryList;

Lines 52-68 Optional<PerformanceEntry::Type> Perform Source/WebCore/page/PerformanceEntry.cpp_sec1
- Source/WebCore/page/PerformanceEntry.cpp -10 / +6 lines
52	if (entryType == "navigation")	52	if (entryType == "navigation")
53	return Optional<Type>(Type::Navigation);	53	return Optional<Type>(Type::Navigation);
54		54
55	if (RuntimeEnabledFeatures::sharedFeatures().userTimingEnabled()) {	55	if (entryType == "mark")
56	if (entryType == "mark")	56	return Optional<Type>(Type::Mark);
57	return Optional<Type>(Type::Mark);	57	if (entryType == "measure")
58	if (entryType == "measure")	58	return Optional<Type>(Type::Measure);
59	return Optional<Type>(Type::Measure);
60	}
61		59
62	if (RuntimeEnabledFeatures::sharedFeatures().resourceTimingEnabled()) {	60	if (entryType == "resource")
63	if (entryType == "resource")	61	return Optional<Type>(Type::Resource);
64	return Optional<Type>(Type::Resource);
65	}
66		62
67	if (RuntimeEnabledFeatures::sharedFeatures().paintTimingEnabled()) {	63	if (RuntimeEnabledFeatures::sharedFeatures().paintTimingEnabled()) {
68	if (entryType == "paint")	64	if (entryType == "paint")

Lines 44-60 namespace WebCore { Source/WebCore/page/RuntimeEnabledFeatures.h_sec1
- Source/WebCore/page/RuntimeEnabledFeatures.h -10 lines
44	class RuntimeEnabledFeatures {	44	class RuntimeEnabledFeatures {
45	WTF_MAKE_NONCOPYABLE(RuntimeEnabledFeatures);	45	WTF_MAKE_NONCOPYABLE(RuntimeEnabledFeatures);
46	public:	46	public:
47	void setResourceTimingEnabled(bool isEnabled) { m_isResourceTimingEnabled = isEnabled; }
48	bool resourceTimingEnabled() const { return m_isResourceTimingEnabled; }
49
50	void setUserTimingEnabled(bool isEnabled) { m_isUserTimingEnabled = isEnabled; }
51	bool userTimingEnabled() const { return m_isUserTimingEnabled; }
52
53	void setPaintTimingEnabled(bool isEnabled) { m_isPaintTimingEnabled = isEnabled; }	47	void setPaintTimingEnabled(bool isEnabled) { m_isPaintTimingEnabled = isEnabled; }
54	bool paintTimingEnabled() const { return m_isPaintTimingEnabled; }	48	bool paintTimingEnabled() const { return m_isPaintTimingEnabled; }
55		49
56	bool performanceTimelineEnabled() const { return resourceTimingEnabled() \|\| userTimingEnabled(); }
57
58	void setMenuItemElementEnabled(bool isEnabled) { m_isMenuItemElementEnabled = isEnabled; }	50	void setMenuItemElementEnabled(bool isEnabled) { m_isMenuItemElementEnabled = isEnabled; }
59	bool menuItemElementEnabled() const { return m_isMenuItemElementEnabled; }	51	bool menuItemElementEnabled() const { return m_isMenuItemElementEnabled; }
60		52
Lines 282-289 private: Source/WebCore/page/RuntimeEnabledFeatures.h_sec2
282		274
283	bool m_areModernMediaControlsEnabled { false };	275	bool m_areModernMediaControlsEnabled { false };
284	bool m_isPaintTimingEnabled { false };	276	bool m_isPaintTimingEnabled { false };
285	bool m_isResourceTimingEnabled { false };
286	bool m_isUserTimingEnabled { false };
287	bool m_isMenuItemElementEnabled { false };	277	bool m_isMenuItemElementEnabled { false };
288	bool m_isDirectoryUploadEnabled { false };	278	bool m_isDirectoryUploadEnabled { false };
289	bool m_isCustomPasteboardDataEnabled { false };	279	bool m_isCustomPasteboardDataEnabled { false };

Lines 1-3 Source/WebKit/ChangeLog_sec1
- Source/WebKit/ChangeLog +20 lines
		1	2020-09-17 Sam Weinig <weinig@apple.com>
		2
		3	Remove runtime setting for enabling/disabling the UserTiming and ResourceTiming APIs
		4	https://bugs.webkit.org/show_bug.cgi?id=216556
		5
		6	Reviewed by NOBODY (OOPS!).
		7
		8	Remove runtime setting for enabling/disabling UserTiming and ResourceTiming
		9	APIs. They have both been on for a while in WebKit2 and there aren't any
		10	known uses cases for disabling them. In addition to removing the setting,
		11	they are now enabled in LegacyWebKit as well.
		12
		13	* Shared/WebPreferences.yaml:
		14	* UIProcess/API/C/WKPreferences.cpp:
		15	(WKPreferencesSetUserTimingEnabled):
		16	(WKPreferencesGetUserTimingEnabled):
		17	(WKPreferencesSetResourceTimingEnabled):
		18	(WKPreferencesGetResourceTimingEnabled):
		19	* UIProcess/API/C/WKPreferencesRefPrivate.h:
		20
1	2020-09-17 Sam Weinig <weinig@apple.com>	21	2020-09-17 Sam Weinig <weinig@apple.com>
2		22
3	We shouldn't need to specify a category for preferences now that they are split into separate files	23	We shouldn't need to specify a category for preferences now that they are split into separate files

Lines 677-696 ModernMediaControlsEnabled: Source/WebKit/Shared/WebPreferences.yaml_sec1
- Source/WebKit/Shared/WebPreferences.yaml -14 lines
677	humanReadableDescription: "Use modern media controls look"	677	humanReadableDescription: "Use modern media controls look"
678	webcoreBinding: RuntimeEnabledFeatures	678	webcoreBinding: RuntimeEnabledFeatures
679		679
680	ResourceTimingEnabled:
681	type: bool
682	defaultValue: true
683	humanReadableName: "Resource Timing"
684	humanReadableDescription: "Enable ResourceTiming API"
685	webcoreBinding: RuntimeEnabledFeatures
686
687	UserTimingEnabled:
688	type: bool
689	defaultValue: true
690	humanReadableName: "User Timing"
691	humanReadableDescription: "Enable UserTiming API"
692	webcoreBinding: RuntimeEnabledFeatures
693
694	BeaconAPIEnabled:	680	BeaconAPIEnabled:
695	type: bool	681	type: bool
696	defaultValue: true	682	defaultValue: true

Lines 1-3 Source/WebKitLegacy/mac/ChangeLog_sec1
- Source/WebKitLegacy/mac/ChangeLog +22 lines
		1	2020-09-17 Sam Weinig <weinig@apple.com>
		2
		3	Remove runtime setting for enabling/disabling the UserTiming and ResourceTiming APIs
		4	https://bugs.webkit.org/show_bug.cgi?id=216556
		5
		6	Reviewed by NOBODY (OOPS!).
		7
		8	Remove runtime setting for enabling/disabling UserTiming and ResourceTiming
		9	APIs. They have both been on for a while in WebKit2 and there aren't any
		10	known uses cases for disabling them. In addition to removing the setting,
		11	they are now enabled in LegacyWebKit as well.
		12
		13	* WebView/WebPreferences.mm:
		14	(+[WebPreferences initialize]):
		15	(-[WebPreferences setUserTimingEnabled:]):
		16	(-[WebPreferences userTimingEnabled]):
		17	(-[WebPreferences setResourceTimingEnabled:]):
		18	(-[WebPreferences resourceTimingEnabled]):
		19	* WebView/WebPreferencesPrivate.h:
		20	* WebView/WebView.mm:
		21	(-[WebView _preferencesChanged:]):
		22
1	2020-09-17 Antoine Quint <graouts@webkit.org>	23	2020-09-17 Antoine Quint <graouts@webkit.org>
2		24
3	Remove the legacy animation code	25	Remove the legacy animation code

Lines 684-691 + (void)initialize Source/WebKitLegacy/mac/WebView/WebPreferences.mm_sec1
- Source/WebKitLegacy/mac/WebView/WebPreferences.mm -22 / +18 lines
684	#if ENABLE(INTERSECTION_OBSERVER)	684	#if ENABLE(INTERSECTION_OBSERVER)
685	@NO, WebKitIntersectionObserverEnabledPreferenceKey,	685	@NO, WebKitIntersectionObserverEnabledPreferenceKey,
686	#endif	686	#endif
687	@NO, WebKitUserTimingEnabledPreferenceKey,
688	@NO, WebKitResourceTimingEnabledPreferenceKey,
689	@NO, WebKitMediaUserGestureInheritsFromDocument,	687	@NO, WebKitMediaUserGestureInheritsFromDocument,
690	@YES, WebKitLegacyEncryptedMediaAPIEnabledKey,	688	@YES, WebKitLegacyEncryptedMediaAPIEnabledKey,
691	@NO, WebKitEncryptedMediaAPIEnabledKey,	689	@NO, WebKitEncryptedMediaAPIEnabledKey,
Lines 3252-3277 - (void)setMenuItemElementEnabled:(BOOL) Source/WebKitLegacy/mac/WebView/WebPreferences.mm_sec2
3252	[self _setBoolValue:flag forKey:WebKitMenuItemElementEnabledPreferenceKey];	3250	[self _setBoolValue:flag forKey:WebKitMenuItemElementEnabledPreferenceKey];
3253	}	3251	}
3254		3252
3255	- (BOOL)userTimingEnabled
3256	{
3257	return [self _boolValueForKey:WebKitUserTimingEnabledPreferenceKey];
3258	}
3259
3260	- (void)setUserTimingEnabled:(BOOL)flag
3261	{
3262	[self _setBoolValue:flag forKey:WebKitUserTimingEnabledPreferenceKey];
3263	}
3264
3265	- (BOOL)resourceTimingEnabled
3266	{
3267	return [self _boolValueForKey:WebKitResourceTimingEnabledPreferenceKey];
3268	}
3269
3270	- (void)setResourceTimingEnabled:(BOOL)flag
3271	{
3272	[self _setBoolValue:flag forKey:WebKitResourceTimingEnabledPreferenceKey];
3273	}
3274
3275	- (BOOL)mediaUserGestureInheritsFromDocument	3253	- (BOOL)mediaUserGestureInheritsFromDocument
3276	{	3254	{
3277	return [self _boolValueForKey:WebKitMediaUserGestureInheritsFromDocument];	3255	return [self _boolValueForKey:WebKitMediaUserGestureInheritsFromDocument];
Lines 3648-3653 + (NSString *)_concatenateKeyWithIBCreat Source/WebKitLegacy/mac/WebView/WebPreferences.mm_sec3
3648	// The preferences in this category are deprecated and have no effect. They should	3626	// The preferences in this category are deprecated and have no effect. They should
3649	// be removed when it is considered safe to do so.	3627	// be removed when it is considered safe to do so.
3650		3628
		3629	- (void)setUserTimingEnabled:(BOOL)flag
		3630	{
		3631	}
		3632
		3633	- (BOOL)userTimingEnabled
		3634	{
		3635	return YES;
		3636	}
		3637
		3638	- (void)setResourceTimingEnabled:(BOOL)flag
		3639	{
		3640	}
		3641
		3642	- (BOOL)resourceTimingEnabled
		3643	{
		3644	return YES;
		3645	}
		3646
3651	- (void)setCSSShadowPartsEnabled:(BOOL)flag	3647	- (void)setCSSShadowPartsEnabled:(BOOL)flag
3652	{	3648	{
3653	}	3649	}

Lines 640-647 @interface WebPreferences (WebPrivate) Source/WebKitLegacy/mac/WebView/WebPreferencesPrivate.h_sec1
- Source/WebKitLegacy/mac/WebView/WebPreferencesPrivate.h -2 / +3 lines
640	@property (nonatomic) BOOL intersectionObserverEnabled;	640	@property (nonatomic) BOOL intersectionObserverEnabled;
641	@property (nonatomic) BOOL menuItemElementEnabled;	641	@property (nonatomic) BOOL menuItemElementEnabled;
642	@property (nonatomic) BOOL keygenElementEnabled;	642	@property (nonatomic) BOOL keygenElementEnabled;
643	@property (nonatomic) BOOL userTimingEnabled;
644	@property (nonatomic) BOOL resourceTimingEnabled;
645	@property (nonatomic) BOOL linkPreloadEnabled;	643	@property (nonatomic) BOOL linkPreloadEnabled;
646	@property (nonatomic) BOOL mediaUserGestureInheritsFromDocument;	644	@property (nonatomic) BOOL mediaUserGestureInheritsFromDocument;
647	@property (nonatomic) BOOL isSecureContextAttributeEnabled;	645	@property (nonatomic) BOOL isSecureContextAttributeEnabled;
Lines 686-691 @interface WebPreferences (WebPrivateDep Source/WebKitLegacy/mac/WebView/WebPreferencesPrivate.h_sec2
686	// The preferences in this category are deprecated and have no effect. They should	684	// The preferences in this category are deprecated and have no effect. They should
687	// be removed when it is considered safe to do so.	685	// be removed when it is considered safe to do so.
688		686
		687	@property (nonatomic) BOOL userTimingEnabled;
		688	@property (nonatomic) BOOL resourceTimingEnabled;
		689
689	- (void)setCSSShadowPartsEnabled:(BOOL)flag;	690	- (void)setCSSShadowPartsEnabled:(BOOL)flag;
690	- (BOOL)cssShadowPartsEnabled;	691	- (BOOL)cssShadowPartsEnabled;
691		692

Lines 3365-3372 - (void)_preferencesChanged:(WebPreferen Source/WebKitLegacy/mac/WebView/WebView.mm_sec1
- Source/WebKitLegacy/mac/WebView/WebView.mm -2 lines
3365	settings.setIntersectionObserverEnabled(preferences.intersectionObserverEnabled);	3365	settings.setIntersectionObserverEnabled(preferences.intersectionObserverEnabled);
3366	#endif	3366	#endif
3367		3367
3368	RuntimeEnabledFeatures::sharedFeatures().setUserTimingEnabled(preferences.userTimingEnabled);
3369	RuntimeEnabledFeatures::sharedFeatures().setResourceTimingEnabled(preferences.resourceTimingEnabled);
3370	settings.setLinkPreloadEnabled(preferences.linkPreloadEnabled);	3368	settings.setLinkPreloadEnabled(preferences.linkPreloadEnabled);
3371	settings.setMediaPreloadingEnabled(preferences.mediaPreloadingEnabled);	3369	settings.setMediaPreloadingEnabled(preferences.mediaPreloadingEnabled);
3372	RuntimeEnabledFeatures::sharedFeatures().setDirectoryUploadEnabled([preferences directoryUploadEnabled]);	3370	RuntimeEnabledFeatures::sharedFeatures().setDirectoryUploadEnabled([preferences directoryUploadEnabled]);

Lines 317-326 void WebPreferences::initializeDefaultSe Source/WebKitLegacy/win/WebPreferences.cpp_sec1
- Source/WebKitLegacy/win/WebPreferences.cpp -10 / +4 lines
317		317
318	CFDictionaryAddValue(defaults, CFSTR(WebKitCSSCustomPropertiesAndValuesEnabledPreferenceKey), kCFBooleanFalse);	318	CFDictionaryAddValue(defaults, CFSTR(WebKitCSSCustomPropertiesAndValuesEnabledPreferenceKey), kCFBooleanFalse);
319		319
320	CFDictionaryAddValue(defaults, CFSTR(WebKitUserTimingEnabledPreferenceKey), kCFBooleanFalse);
321
322	CFDictionaryAddValue(defaults, CFSTR(WebKitResourceTimingEnabledPreferenceKey), kCFBooleanFalse);
323
324	CFDictionaryAddValue(defaults, CFSTR(WebKitLinkPreloadEnabledPreferenceKey), kCFBooleanFalse);	320	CFDictionaryAddValue(defaults, CFSTR(WebKitLinkPreloadEnabledPreferenceKey), kCFBooleanFalse);
325		321
326	CFDictionaryAddValue(defaults, CFSTR(WebKitMediaPreloadingEnabledPreferenceKey), kCFBooleanFalse);	322	CFDictionaryAddValue(defaults, CFSTR(WebKitMediaPreloadingEnabledPreferenceKey), kCFBooleanFalse);
Lines 2361-2369 HRESULT WebPreferences::CSSCustomPropert Source/WebKitLegacy/win/WebPreferences.cpp_sec2
2361	return S_OK;	2357	return S_OK;
2362	}	2358	}
2363		2359
2364	HRESULT WebPreferences::setUserTimingEnabled(BOOL enabled)	2360	HRESULT WebPreferences::setUserTimingEnabled(BOOL)
2365	{	2361	{
2366	setBoolValue(WebKitUserTimingEnabledPreferenceKey, enabled);
2367	return S_OK;	2362	return S_OK;
2368	}	2363	}
2369		2364
Lines 2371-2383 HRESULT WebPreferences::userTimingEnable Source/WebKitLegacy/win/WebPreferences.cpp_sec3
2371	{	2366	{
2372	if (!enabled)	2367	if (!enabled)
2373	return E_POINTER;	2368	return E_POINTER;
2374	*enabled = boolValueForKey(WebKitUserTimingEnabledPreferenceKey);	2369	*enabled = true;
2375	return S_OK;	2370	return S_OK;
2376	}	2371	}
2377		2372
2378	HRESULT WebPreferences::setResourceTimingEnabled(BOOL enabled)	2373	HRESULT WebPreferences::setResourceTimingEnabled(BOOL)
2379	{	2374	{
2380	setBoolValue(WebKitResourceTimingEnabledPreferenceKey, enabled);
2381	return S_OK;	2375	return S_OK;
2382	}	2376	}
2383		2377
Lines 2385-2391 HRESULT WebPreferences::resourceTimingEn Source/WebKitLegacy/win/WebPreferences.cpp_sec4
2385	{	2379	{
2386	if (!enabled)	2380	if (!enabled)
2387	return E_POINTER;	2381	return E_POINTER;
2388	*enabled = boolValueForKey(WebKitResourceTimingEnabledPreferenceKey);	2382	*enabled = true;

Lines 896-903 static void resetWebPreferencesToConsist Tools/DumpRenderTree/win/DumpRenderTree.cpp_sec1
- Tools/DumpRenderTree/win/DumpRenderTree.cpp -2 lines
896		896
897	preferences->setFontSmoothing(FontSmoothingTypeStandard);	897	preferences->setFontSmoothing(FontSmoothingTypeStandard);
898		898
899	prefsPrivate->setResourceTimingEnabled(TRUE);
900	prefsPrivate->setUserTimingEnabled(TRUE);
901	prefsPrivate->setDataTransferItemsEnabled(TRUE);	899	prefsPrivate->setDataTransferItemsEnabled(TRUE);
902	prefsPrivate->clearNetworkLoaderSession();	900	prefsPrivate->clearNetworkLoaderSession();
903		901

Lines 1-3 Source/WebKitLegacy/win/ChangeLog_sec1
- Source/WebKitLegacy/win/ChangeLog +21 lines
		1	2020-09-17 Sam Weinig <weinig@apple.com>
		2
		3	Remove runtime setting for enabling/disabling the UserTiming and ResourceTiming APIs
		4	https://bugs.webkit.org/show_bug.cgi?id=216556
		5
		6	Reviewed by NOBODY (OOPS!).
		7
		8	Remove runtime setting for enabling/disabling UserTiming and ResourceTiming
		9	APIs. They have both been on for a while in WebKit2 and there aren't any
		10	known uses cases for disabling them. In addition to removing the setting,
		11	they are now enabled in LegacyWebKit as well.
		12
		13	* WebPreferences.cpp:
		14	(WebPreferences::initializeDefaultSettings):
		15	(WebPreferences::setUserTimingEnabled):
		16	(WebPreferences::userTimingEnabled):
		17	(WebPreferences::setResourceTimingEnabled):
		18	(WebPreferences::resourceTimingEnabled):
		19	* WebView.cpp:
		20	(WebView::notifyPreferencesChanged):
		21
1	2020-09-17 Antoine Quint <graouts@webkit.org>	22	2020-09-17 Antoine Quint <graouts@webkit.org>
2		23
3	Remove the legacy animation code	24	Remove the legacy animation code

Lines 5259-5274 HRESULT WebView::notifyPreferencesChange Source/WebKitLegacy/win/WebView.cpp_sec1
- Source/WebKitLegacy/win/WebView.cpp -10 lines
5259	return hr;	5259	return hr;
5260	settings.setCSSCustomPropertiesAndValuesEnabled(!!enabled);	5260	settings.setCSSCustomPropertiesAndValuesEnabled(!!enabled);
5261		5261
5262	hr = prefsPrivate->userTimingEnabled(&enabled);
5263	if (FAILED(hr))
5264	return hr;
5265	RuntimeEnabledFeatures::sharedFeatures().setUserTimingEnabled(!!enabled);
5266
5267	hr = prefsPrivate->resourceTimingEnabled(&enabled);
5268	if (FAILED(hr))
5269	return hr;
5270	RuntimeEnabledFeatures::sharedFeatures().setResourceTimingEnabled(!!enabled);
5271
5272	hr = prefsPrivate->linkPreloadEnabled(&enabled);	5262	hr = prefsPrivate->linkPreloadEnabled(&enabled);
5273	if (FAILED(hr))	5263	if (FAILED(hr))
5274	return hr;	5264	return hr;

Lines 1-3 Tools/ChangeLog_sec1
- Tools/ChangeLog +19 lines
		1	2020-09-17 Sam Weinig <weinig@apple.com>
		2
		3	Remove runtime setting for enabling/disabling the UserTiming and ResourceTiming APIs
		4	https://bugs.webkit.org/show_bug.cgi?id=216556
		5
		6	Reviewed by NOBODY (OOPS!).
		7
		8	Remove runtime setting for enabling/disabling UserTiming and ResourceTiming
		9	APIs. They have both been on for a while in WebKit2 and there aren't any
		10	known uses cases for disabling them. In addition to removing the setting,
		11	they are now enabled in LegacyWebKit as well.
		12
		13	* DumpRenderTree/mac/DumpRenderTree.mm:
		14	(resetWebPreferencesToConsistentValues):
		15	* DumpRenderTree/win/DumpRenderTree.cpp:
		16	(resetWebPreferencesToConsistentValues):
		17	* WebKitTestRunner/TestController.cpp:
		18	(WTR::TestController::resetPreferencesToConsistentValues):
		19
1	2020-09-17 Víctor Manuel Jáquez Leal <vjaquez@igalia.com>	20	2020-09-17 Víctor Manuel Jáquez Leal <vjaquez@igalia.com>
2		21
3	[Flatpak SDK] bwrap: add pipewire socket as bind mount	22	[Flatpak SDK] bwrap: add pipewire socket as bind mount

Lines 951-958 static void resetWebPreferencesToConsist Tools/DumpRenderTree/mac/DumpRenderTree.mm_sec1
- Tools/DumpRenderTree/mac/DumpRenderTree.mm -2 lines
951	[preferences setLargeImageAsyncDecodingEnabled:NO];	951	[preferences setLargeImageAsyncDecodingEnabled:NO];
952		952
953	[preferences setModernMediaControlsEnabled:YES];	953	[preferences setModernMediaControlsEnabled:YES];
954	[preferences setResourceTimingEnabled:YES];
955	[preferences setUserTimingEnabled:YES];
956		954
957	[preferences setCacheAPIEnabled:NO];	955	[preferences setCacheAPIEnabled:NO];
958	preferences.mediaCapabilitiesEnabled = YES;	956	preferences.mediaCapabilitiesEnabled = YES;

Lines 956-963 void TestController::resetPreferencesToC Tools/WebKitTestRunner/TestController.cpp_sec1
- Tools/WebKitTestRunner/TestController.cpp -2 lines
956	WKPreferencesSetIsNSURLSessionWebSocketEnabled(preferences, false);	956	WKPreferencesSetIsNSURLSessionWebSocketEnabled(preferences, false);
957		957
958	WKPreferencesSetFetchAPIKeepAliveEnabled(preferences, true);	958	WKPreferencesSetFetchAPIKeepAliveEnabled(preferences, true);
959	WKPreferencesSetResourceTimingEnabled(preferences, true);
960	WKPreferencesSetUserTimingEnabled(preferences, true);
961	WKPreferencesSetMediaPreloadingEnabled(preferences, true);	959	WKPreferencesSetMediaPreloadingEnabled(preferences, true);
962	WKPreferencesSetExposeSpeakersEnabled(preferences, true);	960	WKPreferencesSetExposeSpeakersEnabled(preferences, true);
963	WKPreferencesSetMediaPlaybackAllowsInline(preferences, true);	961	WKPreferencesSetMediaPlaybackAllowsInline(preferences, true);