void NetworkProcess::deleteWebsiteData(SessionID sessionID, OptionSet<WebsiteDataType> websiteDataTypes, std::chrono::system_clock::time_point modifiedSince, uint64_t callbackID)
{
#if PLATFORM(COCOA)
if (websiteDataTypes.contains(WebsiteDataType::HSTSCache)) {
if (auto* networkStorageSession = SessionTracker::storageSession(sessionID))
clearHSTSCache(*networkStorageSession, modifiedSince);
}
#endif
if (websiteDataTypes.contains(WebsiteDataType::Cookies)) {
if (auto* networkStorageSession = SessionTracker::storageSession(sessionID))
deleteAllCookiesModifiedSince(*networkStorageSession, modifiedSince);
}
auto completionHandler = [this, callbackID] {
parentProcessConnection()->send(Messages::NetworkProcessProxy::DidDeleteWebsiteData(callbackID), 0);
};
if (websiteDataTypes.contains(WebsiteDataType::DiskCache) && !sessionID.isEphemeral()) {
clearDiskCache(modifiedSince, WTFMove(completionHandler));
return;
}
completionHandler();
}
EncodedValue EncodingTraits<Test::PlatformEvent::OtherType>::encodeValue(const OptionSet<Test::PlatformEvent::OtherType>& enumValue)
{
EncodedValue encodedValue = EncodedValue::createArray();
if (enumValue.contains(Test::PlatformEvent::OtherType::Mouse))
encodedValue.append<String>(ASCIILiteral("Mouse"));
if (enumValue.contains(Test::PlatformEvent::OtherType::Key))
encodedValue.append<String>(ASCIILiteral("Key"));
if (enumValue.contains(Test::PlatformEvent::OtherType::Touch))
encodedValue.append<String>(ASCIILiteral("Touch"));
if (enumValue.contains(Test::PlatformEvent::OtherType::Wheel))
encodedValue.append<String>(ASCIILiteral("Wheel"));
return encodedValue;
}
void NetworkProcess::deleteWebsiteDataForOrigins(SessionID sessionID, OptionSet<WebsiteDataType> websiteDataTypes, const Vector<SecurityOriginData>& origins, const Vector<String>& cookieHostNames, uint64_t callbackID)
{
if (websiteDataTypes.contains(WebsiteDataType::Cookies)) {
if (auto* networkStorageSession = SessionTracker::storageSession(sessionID))
deleteCookiesForHostnames(*networkStorageSession, cookieHostNames);
}
auto completionHandler = [this, callbackID] {
parentProcessConnection()->send(Messages::NetworkProcessProxy::DidDeleteWebsiteDataForOrigins(callbackID), 0);
};
if (websiteDataTypes.contains(WebsiteDataType::DiskCache) && !sessionID.isEphemeral()) {
clearDiskCacheEntries(origins, WTFMove(completionHandler));
return;
}
completionHandler();
}
void NetworkProcess::fetchWebsiteData(SessionID sessionID, OptionSet<WebsiteDataType> websiteDataTypes, OptionSet<WebsiteDataFetchOption> fetchOptions, uint64_t callbackID)
{
struct CallbackAggregator final : public RefCounted<CallbackAggregator> {
explicit CallbackAggregator(std::function<void (WebsiteData)> completionHandler)
: m_completionHandler(WTFMove(completionHandler))
{
}
~CallbackAggregator()
{
ASSERT(RunLoop::isMain());
auto completionHandler = WTFMove(m_completionHandler);
auto websiteData = WTFMove(m_websiteData);
RunLoop::main().dispatch([completionHandler, websiteData] {
completionHandler(websiteData);
});
}
std::function<void (WebsiteData)> m_completionHandler;
WebsiteData m_websiteData;
};
RefPtr<CallbackAggregator> callbackAggregator = adoptRef(new CallbackAggregator([this, callbackID] (WebsiteData websiteData) {
parentProcessConnection()->send(Messages::NetworkProcessProxy::DidFetchWebsiteData(callbackID, websiteData), 0);
}));
if (websiteDataTypes.contains(WebsiteDataType::Cookies)) {
if (auto* networkStorageSession = SessionTracker::storageSession(sessionID))
getHostnamesWithCookies(*networkStorageSession, callbackAggregator->m_websiteData.hostNamesWithCookies);
}
if (websiteDataTypes.contains(WebsiteDataType::DiskCache)) {
fetchDiskCacheEntries(sessionID, fetchOptions, [callbackAggregator](auto entries) {
callbackAggregator->m_websiteData.entries.appendVector(entries);
});
}
}
static void fetchDiskCacheEntries(SessionID sessionID, OptionSet<WebsiteDataFetchOption> fetchOptions, std::function<void (Vector<WebsiteData::Entry>)> completionHandler)
{
#if ENABLE(NETWORK_CACHE)
if (NetworkCache::singleton().isEnabled()) {
auto* originsAndSizes = new HashMap<RefPtr<SecurityOrigin>, uint64_t>();
NetworkCache::singleton().traverse([fetchOptions, completionHandler, originsAndSizes](auto* traversalEntry) {
if (!traversalEntry) {
Vector<WebsiteData::Entry> entries;
for (auto& originAndSize : *originsAndSizes) {
WebsiteData::Entry entry { originAndSize.key, WebsiteDataType::DiskCache, originAndSize.value };
entries.append(WTFMove(entry));
}
delete originsAndSizes;
RunLoop::main().dispatch([completionHandler, entries] {
completionHandler(entries);
});
return;
}
auto result = originsAndSizes->add(SecurityOrigin::create(traversalEntry->entry.response().url()), 0);
if (fetchOptions.contains(WebsiteDataFetchOption::ComputeSizes))
result.iterator->value += traversalEntry->entry.sourceStorageRecord().header.size() + traversalEntry->recordInfo.bodySize;
});
return;
}
#endif
Vector<WebsiteData::Entry> entries;
#if USE(CFURLCACHE)
for (auto& origin : NetworkProcess::cfURLCacheOrigins())
entries.append(WebsiteData::Entry { WTFMove(origin), WebsiteDataType::DiskCache, 0 });
#endif
RunLoop::main().dispatch([completionHandler, entries] {
completionHandler(entries);
});
}
void swift::performTypeChecking(SourceFile &SF, TopLevelContext &TLC,
OptionSet<TypeCheckingFlags> Options,
unsigned StartElem,
unsigned WarnLongFunctionBodies,
unsigned WarnLongExpressionTypeChecking,
unsigned ExpressionTimeoutThreshold,
unsigned SwitchCheckingInvocationThreshold) {
if (SF.ASTStage == SourceFile::TypeChecked)
return;
auto &Ctx = SF.getASTContext();
// Make sure we have a type checker.
TypeChecker &TC = createTypeChecker(Ctx);
// Make sure that name binding has been completed before doing any type
// checking.
performNameBinding(SF, StartElem);
{
SharedTimer timer("Type checking / Semantic analysis");
TC.setWarnLongFunctionBodies(WarnLongFunctionBodies);
TC.setWarnLongExpressionTypeChecking(WarnLongExpressionTypeChecking);
if (ExpressionTimeoutThreshold != 0)
TC.setExpressionTimeoutThreshold(ExpressionTimeoutThreshold);
if (SwitchCheckingInvocationThreshold != 0)
TC.setSwitchCheckingInvocationThreshold(
SwitchCheckingInvocationThreshold);
if (Options.contains(TypeCheckingFlags::DebugTimeFunctionBodies))
TC.enableDebugTimeFunctionBodies();
if (Options.contains(TypeCheckingFlags::DebugTimeExpressions))
TC.enableDebugTimeExpressions();
if (Options.contains(TypeCheckingFlags::ForImmediateMode))
TC.setInImmediateMode(true);
// Lookup the swift module. This ensures that we record all known
// protocols in the AST.
(void) TC.getStdlibModule(&SF);
if (!Ctx.LangOpts.DisableAvailabilityChecking) {
// Build the type refinement hierarchy for the primary
// file before type checking.
TC.buildTypeRefinementContextHierarchy(SF, StartElem);
}
// Resolve extensions. This has to occur first during type checking,
// because the extensions need to be wired into the AST for name lookup
// to work.
bindExtensions(SF, TC);
// Look for bridging functions. This only matters when
// -enable-source-import is provided.
checkBridgedFunctions(TC.Context);
// Type check the top-level elements of the source file.
bool hasTopLevelCode = false;
for (auto D : llvm::makeArrayRef(SF.Decls).slice(StartElem)) {
if (auto *TLCD = dyn_cast<TopLevelCodeDecl>(D)) {
hasTopLevelCode = true;
// Immediately perform global name-binding etc.
TC.typeCheckTopLevelCodeDecl(TLCD);
} else {
TC.typeCheckDecl(D);
}
}
if (hasTopLevelCode) {
TC.contextualizeTopLevelCode(TLC,
llvm::makeArrayRef(SF.Decls).slice(StartElem));
}
// If we're in REPL mode, inject temporary result variables and other stuff
// that the REPL needs to synthesize.
if (SF.Kind == SourceFileKind::REPL && !Ctx.hadError())
TC.processREPLTopLevel(SF, TLC, StartElem);
typeCheckFunctionsAndExternalDecls(SF, TC);
}
// Checking that benefits from having the whole module available.
if (!(Options & TypeCheckingFlags::DelayWholeModuleChecking)) {
performWholeModuleTypeChecking(SF);
}
// Verify that we've checked types correctly.
SF.ASTStage = SourceFile::TypeChecked;
{
SharedTimer timer("AST verification");
// Verify the SourceFile.
verify(SF);
// Verify imported modules.
//
// Skip per-file verification in whole-module mode. Verifying imports
// between files could cause the importer to cache declarations without
// adding them to the ASTContext. This happens when the importer registers a
// declaration without a valid TypeChecker instance, as is the case during
// verification. A subsequent file may require that declaration to be fully
// imported (e.g. to synthesized a function body), but since it has already
// been cached, it will never be added to the ASTContext. The solution is to
// skip verification and avoid caching it.
#ifndef NDEBUG
if (!(Options & TypeCheckingFlags::DelayWholeModuleChecking) &&
SF.Kind != SourceFileKind::REPL &&
SF.Kind != SourceFileKind::SIL &&
!Ctx.LangOpts.DebuggerSupport) {
Ctx.verifyAllLoadedModules();
}
#endif
}
}
void swift::performTypeChecking(SourceFile &SF, TopLevelContext &TLC,
OptionSet<TypeCheckingFlags> Options,
unsigned StartElem,
unsigned WarnLongFunctionBodies) {
if (SF.ASTStage == SourceFile::TypeChecked)
return;
auto &Ctx = SF.getASTContext();
// Make sure we have a type checker.
Optional<TypeChecker> MyTC;
if (!Ctx.getLazyResolver())
MyTC.emplace(Ctx);
// Make sure that name binding has been completed before doing any type
// checking.
{
SharedTimer timer("Name binding");
performNameBinding(SF, StartElem);
}
{
// NOTE: The type checker is scoped to be torn down before AST
// verification.
SharedTimer timer("Type checking / Semantic analysis");
if (MyTC) {
MyTC->setWarnLongFunctionBodies(WarnLongFunctionBodies);
if (Options.contains(TypeCheckingFlags::DebugTimeFunctionBodies))
MyTC->enableDebugTimeFunctionBodies();
if (Options.contains(TypeCheckingFlags::DebugTimeExpressions))
MyTC->enableDebugTimeExpressions();
if (Options.contains(TypeCheckingFlags::ForImmediateMode))
MyTC->setInImmediateMode(true);
// Lookup the swift module. This ensures that we record all known
// protocols in the AST.
(void) MyTC->getStdlibModule(&SF);
if (!Ctx.LangOpts.DisableAvailabilityChecking) {
// Build the type refinement hierarchy for the primary
// file before type checking.
MyTC->buildTypeRefinementContextHierarchy(SF, StartElem);
}
}
TypeChecker &TC =
MyTC ? *MyTC : *static_cast<TypeChecker *>(Ctx.getLazyResolver());
// Resolve extensions. This has to occur first during type checking,
// because the extensions need to be wired into the AST for name lookup
// to work.
// FIXME: We can have interesting ordering dependencies among the various
// extensions, so we'll need to be smarter here.
// FIXME: The current source file needs to be handled specially, because of
// private extensions.
SF.forAllVisibleModules([&](ModuleDecl::ImportedModule import) {
// FIXME: Respect the access path?
for (auto file : import.second->getFiles()) {
auto SF = dyn_cast<SourceFile>(file);
if (!SF)
continue;
for (auto D : SF->Decls) {
if (auto ED = dyn_cast<ExtensionDecl>(D))
bindExtensionDecl(ED, TC);
}
}
});
// FIXME: Check for cycles in class inheritance here?
// Type check the top-level elements of the source file.
for (auto D : llvm::makeArrayRef(SF.Decls).slice(StartElem)) {
if (isa<TopLevelCodeDecl>(D))
continue;
TC.typeCheckDecl(D, /*isFirstPass*/true);
}
// At this point, we can perform general name lookup into any type.
// We don't know the types of all the global declarations in the first
// pass, which means we can't completely analyze everything. Perform the
// second pass now.
bool hasTopLevelCode = false;
for (auto D : llvm::makeArrayRef(SF.Decls).slice(StartElem)) {
if (TopLevelCodeDecl *TLCD = dyn_cast<TopLevelCodeDecl>(D)) {
hasTopLevelCode = true;
// Immediately perform global name-binding etc.
TC.typeCheckTopLevelCodeDecl(TLCD);
} else {
TC.typeCheckDecl(D, /*isFirstPass*/false);
}
}
if (hasTopLevelCode) {
TC.contextualizeTopLevelCode(TLC,
llvm::makeArrayRef(SF.Decls).slice(StartElem));
}
// If we're in REPL mode, inject temporary result variables and other stuff
// that the REPL needs to synthesize.
if (SF.Kind == SourceFileKind::REPL && !Ctx.hadError())
TC.processREPLTopLevel(SF, TLC, StartElem);
typeCheckFunctionsAndExternalDecls(TC);
}
MyTC.reset();
// Checking that benefits from having the whole module available.
if (!(Options & TypeCheckingFlags::DelayWholeModuleChecking)) {
performWholeModuleTypeChecking(SF);
}
// Verify that we've checked types correctly.
SF.ASTStage = SourceFile::TypeChecked;
{
SharedTimer timer("AST verification");
// Verify the SourceFile.
verify(SF);
// Verify imported modules.
#ifndef NDEBUG
if (SF.Kind != SourceFileKind::REPL &&
SF.Kind != SourceFileKind::SIL &&
!Ctx.LangOpts.DebuggerSupport) {
Ctx.verifyAllLoadedModules();
}
#endif
}
}