NetworkResourceLoadParameters.cpp [plain text]
#include "config.h"
#include "NetworkResourceLoadParameters.h"
#include "ArgumentCoders.h"
#include "DataReference.h"
#include "WebCoreArgumentCoders.h"
#include <WebCore/SecurityOriginData.h>
using namespace WebCore;
namespace WebKit {
void NetworkResourceLoadParameters::encode(IPC::Encoder& encoder) const
{
encoder << identifier;
encoder << webPageID;
encoder << webFrameID;
encoder << sessionID;
encoder << request;
encoder << static_cast<bool>(request.httpBody());
if (request.httpBody()) {
request.httpBody()->encode(encoder);
const Vector<FormDataElement>& elements = request.httpBody()->elements();
size_t fileCount = 0;
for (size_t i = 0, count = elements.size(); i < count; ++i) {
if (elements[i].m_type == FormDataElement::Type::EncodedFile)
++fileCount;
}
SandboxExtension::HandleArray requestBodySandboxExtensions;
requestBodySandboxExtensions.allocate(fileCount);
size_t extensionIndex = 0;
for (size_t i = 0, count = elements.size(); i < count; ++i) {
const FormDataElement& element = elements[i];
if (element.m_type == FormDataElement::Type::EncodedFile) {
const String& path = element.m_shouldGenerateFile ? element.m_generatedFilename : element.m_filename;
SandboxExtension::createHandle(path, SandboxExtension::Type::ReadOnly, requestBodySandboxExtensions[extensionIndex++]);
}
}
encoder << requestBodySandboxExtensions;
}
if (request.url().isLocalFile()) {
SandboxExtension::Handle requestSandboxExtension;
SandboxExtension::createHandle(request.url().fileSystemPath(), SandboxExtension::Type::ReadOnly, requestSandboxExtension);
encoder << requestSandboxExtension;
}
encoder.encodeEnum(contentSniffingPolicy);
encoder.encodeEnum(contentEncodingSniffingPolicy);
encoder.encodeEnum(storedCredentialsPolicy);
encoder.encodeEnum(clientCredentialPolicy);
encoder.encodeEnum(shouldPreconnectOnly);
encoder << shouldFollowRedirects;
encoder << shouldClearReferrerOnHTTPSToHTTPRedirect;
encoder << defersLoading;
encoder << needsCertificateInfo;
encoder << isMainFrameNavigation;
encoder << maximumBufferingTime;
encoder << derivedCachedDataTypesToRetrieve;
encoder << static_cast<bool>(sourceOrigin);
if (sourceOrigin)
encoder << *sourceOrigin;
encoder << options;
encoder << cspResponseHeaders;
encoder << originalRequestHeaders;
encoder << shouldRestrictHTTPResponseAccess;
encoder.encodeEnum(preflightPolicy);
encoder << shouldEnableCrossOriginResourcePolicy;
encoder << frameAncestorOrigins;
#if ENABLE(CONTENT_EXTENSIONS)
encoder << mainDocumentURL;
encoder << userContentControllerIdentifier;
#endif
}
bool NetworkResourceLoadParameters::decode(IPC::Decoder& decoder, NetworkResourceLoadParameters& result)
{
if (!decoder.decode(result.identifier))
return false;
if (!decoder.decode(result.webPageID))
return false;
if (!decoder.decode(result.webFrameID))
return false;
if (!decoder.decode(result.sessionID))
return false;
if (!decoder.decode(result.request))
return false;
bool hasHTTPBody;
if (!decoder.decode(hasHTTPBody))
return false;
if (hasHTTPBody) {
RefPtr<FormData> formData = FormData::decode(decoder);
if (!formData)
return false;
result.request.setHTTPBody(WTFMove(formData));
SandboxExtension::HandleArray requestBodySandboxExtensionHandles;
if (!decoder.decode(requestBodySandboxExtensionHandles))
return false;
for (size_t i = 0; i < requestBodySandboxExtensionHandles.size(); ++i) {
if (auto extension = SandboxExtension::create(WTFMove(requestBodySandboxExtensionHandles[i])))
result.requestBodySandboxExtensions.append(WTFMove(extension));
}
}
if (result.request.url().isLocalFile()) {
std::optional<SandboxExtension::Handle> resourceSandboxExtensionHandle;
decoder >> resourceSandboxExtensionHandle;
if (!resourceSandboxExtensionHandle)
return false;
result.resourceSandboxExtension = SandboxExtension::create(WTFMove(*resourceSandboxExtensionHandle));
}
if (!decoder.decodeEnum(result.contentSniffingPolicy))
return false;
if (!decoder.decodeEnum(result.contentEncodingSniffingPolicy))
return false;
if (!decoder.decodeEnum(result.storedCredentialsPolicy))
return false;
if (!decoder.decodeEnum(result.clientCredentialPolicy))
return false;
if (!decoder.decodeEnum(result.shouldPreconnectOnly))
return false;
if (!decoder.decode(result.shouldFollowRedirects))
return false;
if (!decoder.decode(result.shouldClearReferrerOnHTTPSToHTTPRedirect))
return false;
if (!decoder.decode(result.defersLoading))
return false;
if (!decoder.decode(result.needsCertificateInfo))
return false;
if (!decoder.decode(result.isMainFrameNavigation))
return false;
if (!decoder.decode(result.maximumBufferingTime))
return false;
if (!decoder.decode(result.derivedCachedDataTypesToRetrieve))
return false;
bool hasSourceOrigin;
if (!decoder.decode(hasSourceOrigin))
return false;
if (hasSourceOrigin) {
result.sourceOrigin = SecurityOrigin::decode(decoder);
if (!result.sourceOrigin)
return false;
}
std::optional<FetchOptions> options;
decoder >> options;
if (!options)
return false;
result.options = *options;
if (!decoder.decode(result.cspResponseHeaders))
return false;
if (!decoder.decode(result.originalRequestHeaders))
return false;
std::optional<bool> shouldRestrictHTTPResponseAccess;
decoder >> shouldRestrictHTTPResponseAccess;
if (!shouldRestrictHTTPResponseAccess)
return false;
result.shouldRestrictHTTPResponseAccess = *shouldRestrictHTTPResponseAccess;
if (!decoder.decodeEnum(result.preflightPolicy))
return false;
std::optional<bool> shouldEnableCrossOriginResourcePolicy;
decoder >> shouldEnableCrossOriginResourcePolicy;
if (!shouldEnableCrossOriginResourcePolicy)
return false;
result.shouldEnableCrossOriginResourcePolicy = *shouldEnableCrossOriginResourcePolicy;
if (!decoder.decode(result.frameAncestorOrigins))
return false;
#if ENABLE(CONTENT_EXTENSIONS)
if (!decoder.decode(result.mainDocumentURL))
return false;
std::optional<std::optional<UserContentControllerIdentifier>> userContentControllerIdentifier;
decoder >> userContentControllerIdentifier;
if (!userContentControllerIdentifier)
return false;
result.userContentControllerIdentifier = *userContentControllerIdentifier;
#endif
return true;
}
}