logo

etc_portage

Unnamed repository; edit this file 'description' to name the repository. git clone https://hacktivis.me/git/etc_portage.git

0007-Revert-Remove-support-for-PING-in-HTML-anchors-priva.patch (20979B)

    

  1. From aa8f18d92cc4b753e1cdfe345b5bb0894bcdc2dc Mon Sep 17 00:00:00 2001
  2. From: "Haelwenn (lanodan) Monnier" <contact@hacktivis.me>
  3. Date: Wed, 13 Mar 2019 11:04:41 +0100
  4. Subject: [PATCH 7/8] Revert "Remove support for PING in HTML anchors
  5.  [privacy]"
  7. This reverts commit 84921f7b5e96acf31472acd7752ca77158b4c657.
  8. ---
  9.  Source/WebCore/Sources.txt                    |   1 +
  10.  Source/WebCore/html/HTMLAnchorElement.cpp     |  16 ++
  11.  .../html/parser/XSSAuditorDelegate.cpp        |   4 +
  12.  Source/WebCore/loader/DocumentLoader.cpp      |   6 +
  13.  Source/WebCore/loader/PingLoader.cpp          | 218 ++++++++++++++++++
  14.  Source/WebCore/loader/PingLoader.h            |  62 +++++
  15.  .../loader/cache/CachedResourceLoader.cpp     |   3 +
  16.  .../page/csp/ContentSecurityPolicy.cpp        |   5 +
  17.  Source/WebKit/WebProcess/WebPage/WebPage.cpp  |   3 +
  18.  9 files changed, 318 insertions(+)
  19.  create mode 100644 Source/WebCore/loader/PingLoader.cpp
  20.  create mode 100644 Source/WebCore/loader/PingLoader.h
  22. diff --git a/Source/WebCore/Sources.txt b/Source/WebCore/Sources.txt
  23. index bbee4a0695..704e50c773 100644
  24. --- a/Source/WebCore/Sources.txt
  25. +++ b/Source/WebCore/Sources.txt
  26. @@ -1276,6 +1276,7 @@ loader/NavigationAction.cpp
  27.  loader/NavigationScheduler.cpp
  28.  loader/NetscapePlugInStreamLoader.cpp
  29.  loader/ServerTimingParser.cpp
  30. +loader/PingLoader.cpp
  31.  loader/PolicyChecker.cpp
  32.  loader/ProgressTracker.cpp
  33.  loader/ResourceCryptographicDigest.cpp
  34. diff --git a/Source/WebCore/html/HTMLAnchorElement.cpp b/Source/WebCore/html/HTMLAnchorElement.cpp
  35. index e53302748d..0155fc70a1 100644
  36. --- a/Source/WebCore/html/HTMLAnchorElement.cpp
  37. +++ b/Source/WebCore/html/HTMLAnchorElement.cpp
  38. @@ -39,6 +39,7 @@
  39.  #include "HTMLPictureElement.h"
  40.  #include "KeyboardEvent.h"
  41.  #include "MouseEvent.h"
  42. +#include "PingLoader.h"
  43.  #include "PlatformMouseEvent.h"
  44.  #include "RenderImage.h"
  45.  #include "ResourceRequest.h"
  46. @@ -363,6 +364,19 @@ bool HTMLAnchorElement::isLiveLink() const
  47.      return isLink() && treatLinkAsLiveForEventType(m_wasShiftKeyDownOnMouseDown ? MouseEventWithShiftKey : MouseEventWithoutShiftKey);
  48.  }
  49.  
  50. +void HTMLAnchorElement::sendPings(const URL& destinationURL)
  51. +{
  52. +    if (!document().frame())
  53. +        return;
  54. +
  55. +    if (!hasAttributeWithoutSynchronization(pingAttr) || !document().settings().hyperlinkAuditingEnabled())
  56. +        return;
  57. +
  58. +    SpaceSplitString pingURLs(attributeWithoutSynchronization(pingAttr), false);
  59. +    for (unsigned i = 0; i < pingURLs.size(); i++)
  60. +        PingLoader::sendPing(*document().frame(), document().completeURL(pingURLs[i]), destinationURL);
  61. +}
  62. +
  63.  #if USE(SYSTEM_PREVIEW)
  64.  bool HTMLAnchorElement::isSystemPreviewLink() const
  65.  {
  66. @@ -428,6 +442,8 @@ void HTMLAnchorElement::handleClick(Event& event)
  67.      ShouldSendReferrer shouldSendReferrer = hasRel(Relation::NoReferrer) ? NeverSendReferrer : MaybeSendReferrer;
  68.      auto newFrameOpenerPolicy = hasRel(Relation::NoOpener) ? std::make_optional(NewFrameOpenerPolicy::Suppress) : std::nullopt;
  69.      frame->loader().urlSelected(completedURL, target(), &event, LockHistory::No, LockBackForwardList::No, shouldSendReferrer, document().shouldOpenExternalURLsPolicyToPropagate(), newFrameOpenerPolicy, downloadAttribute, systemPreviewInfo);
  70. +
  71. +    sendPings(completedURL);
  72.  }
  73.  
  74.  HTMLAnchorElement::EventType HTMLAnchorElement::eventType(Event& event)
  75. diff --git a/Source/WebCore/html/parser/XSSAuditorDelegate.cpp b/Source/WebCore/html/parser/XSSAuditorDelegate.cpp
  76. index e8c69162aa..80b4213669 100644
  77. --- a/Source/WebCore/html/parser/XSSAuditorDelegate.cpp
  78. +++ b/Source/WebCore/html/parser/XSSAuditorDelegate.cpp
  79. @@ -35,6 +35,7 @@
  80.  #include "FrameLoaderClient.h"
  81.  #include "HTMLParserIdioms.h"
  82.  #include "NavigationScheduler.h"
  83. +#include "PingLoader.h"
  84.  #include <wtf/JSONValues.h>
  85.  #include <wtf/text/StringBuilder.h>
  86.  #include <wtf/text/CString.h>
  87. @@ -103,6 +104,9 @@ void XSSAuditorDelegate::didBlockScript(const XSSInfo& xssInfo)
  88.          m_didSendNotifications = true;
  89.  
  90.          frameLoader.client().didDetectXSS(m_document.url(), xssInfo.m_didBlockEntirePage);
  91. +
  92. +        if (!m_reportURL.isEmpty())
  93. +            PingLoader::sendViolationReport(*m_document.frame(), m_reportURL, generateViolationReport(xssInfo), ViolationReportType::XSSAuditor);
  94.      }
  95.  
  96.      if (xssInfo.m_didBlockEntirePage)
  97. diff --git a/Source/WebCore/loader/DocumentLoader.cpp b/Source/WebCore/loader/DocumentLoader.cpp
  98. index 37cf9602b2..b9fc289660 100644
  99. --- a/Source/WebCore/loader/DocumentLoader.cpp
  100. +++ b/Source/WebCore/loader/DocumentLoader.cpp
  101. @@ -65,6 +65,7 @@
  102.  #include "MemoryCache.h"
  103.  #include "NetworkLoadMetrics.h"
  104.  #include "Page.h"
  105. +#include "PingLoader.h"
  106.  #include "PlatformStrategies.h"
  107.  #include "PolicyChecker.h"
  108.  #include "ProgressTracker.h"
  109. @@ -2057,6 +2058,11 @@ void DocumentLoader::addConsoleMessage(MessageSource messageSource, MessageLevel
  110.      static_cast<ScriptExecutionContext*>(m_frame->document())->addConsoleMessage(messageSource, messageLevel, message, requestIdentifier);
  111.  }
  112.  
  113. +void DocumentLoader::sendCSPViolationReport(URL&& reportURL, Ref<FormData>&& report)
  114. +{
  115. +    PingLoader::sendViolationReport(*m_frame, WTFMove(reportURL), WTFMove(report), ViolationReportType::ContentSecurityPolicy);
  116. +}
  117. +
  118.  void DocumentLoader::enqueueSecurityPolicyViolationEvent(SecurityPolicyViolationEvent::Init&& eventInit)
  119.  {
  120.      m_frame->document()->enqueueSecurityPolicyViolationEvent(WTFMove(eventInit));
  121. diff --git a/Source/WebCore/loader/PingLoader.cpp b/Source/WebCore/loader/PingLoader.cpp
  122. new file mode 100644
  123. index 0000000000..134e5560e6
  124. --- /dev/null
  125. +++ b/Source/WebCore/loader/PingLoader.cpp
  126. @@ -0,0 +1,218 @@
  127. +/*
  128. + * Copyright (C) 2010 Google Inc. All rights reserved.
  129. + * Copyright (C) 2015 Roopesh Chander (roop@roopc.net)
  130. + * Copyright (C) 2015-2017 Apple Inc. All rights reserved.
  131. + *
  132. + * Redistribution and use in source and binary forms, with or without
  133. + * modification, are permitted provided that the following conditions are
  134. + * met:
  135. + *
  136. + *     * Redistributions of source code must retain the above copyright
  137. + * notice, this list of conditions and the following disclaimer.
  138. + *     * Redistributions in binary form must reproduce the above
  139. + * copyright notice, this list of conditions and the following disclaimer
  140. + * in the documentation and/or other materials provided with the
  141. + * distribution.
  142. + *     * Neither the name of Google Inc. nor the names of its
  143. + * contributors may be used to endorse or promote products derived from
  144. + * this software without specific prior written permission.
  145. + *
  146. + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  147. + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  148. + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  149. + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  150. + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  151. + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  152. + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  153. + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  154. + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  155. + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  156. + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  157. + *
  158. + */
  159. +
  160. +#include "config.h"
  161. +#include "PingLoader.h"
  162. +
  163. +#include "ContentSecurityPolicy.h"
  164. +#include "Document.h"
  165. +#include "Frame.h"
  166. +#include "FrameLoader.h"
  167. +#include "FrameLoaderClient.h"
  168. +#include "InspectorInstrumentation.h"
  169. +#include "LoaderStrategy.h"
  170. +#include "NetworkLoadMetrics.h"
  171. +#include "Page.h"
  172. +#include "PlatformStrategies.h"
  173. +#include "ProgressTracker.h"
  174. +#include "ResourceHandle.h"
  175. +#include "ResourceLoadInfo.h"
  176. +#include "ResourceRequest.h"
  177. +#include "ResourceResponse.h"
  178. +#include "SecurityOrigin.h"
  179. +#include "SecurityPolicy.h"
  180. +#include "UserContentController.h"
  181. +#include <wtf/text/CString.h>
  182. +
  183. +namespace WebCore {
  184. +
  185. +#if !ENABLE(CONTENT_EXTENSIONS)
  186. +
  187. +// Returns true if we should block the load.
  188. +static inline bool processContentExtensionRulesForLoad(const Frame&, ResourceRequest&, ResourceType)
  189. +{
  190. +    return false;
  191. +}
  192. +
  193. +#else
  194. +
  195. +// Returns true if we should block the load.
  196. +static bool processContentExtensionRulesForLoad(const Frame& frame, ResourceRequest& request, ResourceType resourceType)
  197. +{
  198. +    auto* documentLoader = frame.loader().documentLoader();
  199. +    if (!documentLoader)
  200. +        return false;
  201. +    auto* page = frame.page();
  202. +    if (!page)
  203. +        return false;
  204. +    auto status = page->userContentProvider().processContentExtensionRulesForLoad(request.url(), resourceType, *documentLoader);
  205. +    applyBlockedStatusToRequest(status, page, request);
  206. +    return status.blockedLoad;
  207. +}
  208. +
  209. +#endif
  210. +
  211. +void PingLoader::loadImage(Frame& frame, const URL& url)
  212. +{
  213. +    ASSERT(frame.document());
  214. +    auto& document = *frame.document();
  215. +
  216. +    if (!document.securityOrigin().canDisplay(url)) {
  217. +        FrameLoader::reportLocalLoadFailed(&frame, url);
  218. +        return;
  219. +    }
  220. +
  221. +    ResourceRequest request(url);
  222. +    if (processContentExtensionRulesForLoad(frame, request, ResourceType::Image))
  223. +        return;
  224. +
  225. +    document.contentSecurityPolicy()->upgradeInsecureRequestIfNeeded(request, ContentSecurityPolicy::InsecureRequestType::Load);
  226. +
  227. +    request.setHTTPHeaderField(HTTPHeaderName::CacheControl, "max-age=0");
  228. +
  229. +    HTTPHeaderMap originalRequestHeader = request.httpHeaderFields();
  230. +
  231. +    String referrer = SecurityPolicy::generateReferrerHeader(document.referrerPolicy(), request.url(), frame.loader().outgoingReferrer());
  232. +    if (!referrer.isEmpty())
  233. +        request.setHTTPReferrer(referrer);
  234. +    frame.loader().addExtraFieldsToSubresourceRequest(request);
  235. +
  236. +    startPingLoad(frame, request, WTFMove(originalRequestHeader), ShouldFollowRedirects::Yes);
  237. +}
  238. +
  239. +// http://www.whatwg.org/specs/web-apps/current-work/multipage/links.html#hyperlink-auditing
  240. +void PingLoader::sendPing(Frame& frame, const URL& pingURL, const URL& destinationURL)
  241. +{
  242. +    ASSERT(frame.document());
  243. +
  244. +    if (!pingURL.protocolIsInHTTPFamily())
  245. +        return;
  246. +
  247. +    ResourceRequest request(pingURL);
  248. +    if (processContentExtensionRulesForLoad(frame, request, ResourceType::Raw))
  249. +        return;
  250. +
  251. +    auto& document = *frame.document();
  252. +    document.contentSecurityPolicy()->upgradeInsecureRequestIfNeeded(request, ContentSecurityPolicy::InsecureRequestType::Load);
  253. +
  254. +    request.setHTTPMethod("POST");
  255. +    request.setHTTPContentType("text/ping");
  256. +    request.setHTTPBody(FormData::create("PING"));
  257. +    request.setHTTPHeaderField(HTTPHeaderName::CacheControl, "max-age=0");
  258. +
  259. +    HTTPHeaderMap originalRequestHeader = request.httpHeaderFields();
  260. +
  261. +    frame.loader().addExtraFieldsToSubresourceRequest(request);
  262. +
  263. +    auto& sourceOrigin = document.securityOrigin();
  264. +    FrameLoader::addHTTPOriginIfNeeded(request, sourceOrigin.toString());
  265. +    request.setHTTPHeaderField(HTTPHeaderName::PingTo, destinationURL);
  266. +    if (!SecurityPolicy::shouldHideReferrer(pingURL, frame.loader().outgoingReferrer())) {
  267. +        request.setHTTPHeaderField(HTTPHeaderName::PingFrom, document.url());
  268. +        if (!sourceOrigin.isSameSchemeHostPort(SecurityOrigin::create(pingURL).get())) {
  269. +            String referrer = SecurityPolicy::generateReferrerHeader(document.referrerPolicy(), pingURL, frame.loader().outgoingReferrer());
  270. +            if (!referrer.isEmpty())
  271. +                request.setHTTPReferrer(referrer);
  272. +        }
  273. +    }
  274. +
  275. +    startPingLoad(frame, request, WTFMove(originalRequestHeader), ShouldFollowRedirects::Yes);
  276. +}
  277. +
  278. +void PingLoader::sendViolationReport(Frame& frame, const URL& reportURL, Ref<FormData>&& report, ViolationReportType reportType)
  279. +{
  280. +    ASSERT(frame.document());
  281. +
  282. +    ResourceRequest request(reportURL);
  283. +    if (processContentExtensionRulesForLoad(frame, request, ResourceType::Raw))
  284. +        return;
  285. +
  286. +    auto& document = *frame.document();
  287. +    document.contentSecurityPolicy()->upgradeInsecureRequestIfNeeded(request, ContentSecurityPolicy::InsecureRequestType::Load);
  288. +
  289. +    request.setHTTPMethod("POST"_s);
  290. +    request.setHTTPBody(WTFMove(report));
  291. +    switch (reportType) {
  292. +    case ViolationReportType::ContentSecurityPolicy:
  293. +        request.setHTTPContentType("application/csp-report"_s);
  294. +        break;
  295. +    case ViolationReportType::XSSAuditor:
  296. +        request.setHTTPContentType("application/json"_s);
  297. +        break;
  298. +    }
  299. +
  300. +    bool removeCookies = true;
  301. +    if (document.securityOrigin().isSameSchemeHostPort(SecurityOrigin::create(reportURL).get()))
  302. +        removeCookies = false;
  303. +    if (removeCookies)
  304. +        request.setAllowCookies(false);
  305. +
  306. +    HTTPHeaderMap originalRequestHeader = request.httpHeaderFields();
  307. +
  308. +    frame.loader().addExtraFieldsToSubresourceRequest(request);
  309. +
  310. +    String referrer = SecurityPolicy::generateReferrerHeader(document.referrerPolicy(), reportURL, frame.loader().outgoingReferrer());
  311. +    if (!referrer.isEmpty())
  312. +        request.setHTTPReferrer(referrer);
  313. +
  314. +    startPingLoad(frame, request, WTFMove(originalRequestHeader), ShouldFollowRedirects::No);
  315. +}
  316. +
  317. +void PingLoader::startPingLoad(Frame& frame, ResourceRequest& request, HTTPHeaderMap&& originalRequestHeaders, ShouldFollowRedirects shouldFollowRedirects)
  318. +{
  319. +    unsigned long identifier = frame.page()->progress().createUniqueIdentifier();
  320. +    // FIXME: Why activeDocumentLoader? I would have expected documentLoader().
  321. +    // It seems like the PingLoader should be associated with the current
  322. +    // Document in the Frame, but the activeDocumentLoader will be associated
  323. +    // with the provisional DocumentLoader if there is a provisional
  324. +    // DocumentLoader.
  325. +    bool shouldUseCredentialStorage = frame.loader().client().shouldUseCredentialStorage(frame.loader().activeDocumentLoader(), identifier);
  326. +    FetchOptions options;
  327. +    options.credentials = shouldUseCredentialStorage ? FetchOptions::Credentials::Include : FetchOptions::Credentials::Omit;
  328. +    options.redirect = shouldFollowRedirects == ShouldFollowRedirects::Yes ? FetchOptions::Redirect::Follow : FetchOptions::Redirect::Error;
  329. +
  330. +    // FIXME: Move ping loads to normal subresource loading to get normal inspector request instrumentation hooks.
  331. +    InspectorInstrumentation::willSendRequestOfType(&frame, identifier, frame.loader().activeDocumentLoader(), request, InspectorInstrumentation::LoadType::Ping);
  332. +
  333. +    platformStrategies()->loaderStrategy()->startPingLoad(frame, request, WTFMove(originalRequestHeaders), options, [protectedFrame = makeRef(frame), identifier] (const ResourceError& error, const ResourceResponse& response) {
  334. +        if (!response.isNull())
  335. +            InspectorInstrumentation::didReceiveResourceResponse(protectedFrame, identifier, protectedFrame->loader().activeDocumentLoader(), response, nullptr);
  336. +        if (error.isNull()) {
  337. +            NetworkLoadMetrics emptyMetrics;
  338. +            InspectorInstrumentation::didFinishLoading(protectedFrame.ptr(), protectedFrame->loader().activeDocumentLoader(), identifier, emptyMetrics, nullptr);
  339. +        } else
  340. +            InspectorInstrumentation::didFailLoading(protectedFrame.ptr(), protectedFrame->loader().activeDocumentLoader(), identifier, error);
  341. +    });
  342. +}
  343. +
  344. +}
  345. diff --git a/Source/WebCore/loader/PingLoader.h b/Source/WebCore/loader/PingLoader.h
  346. new file mode 100644
  347. index 0000000000..15489dcf04
  348. --- /dev/null
  349. +++ b/Source/WebCore/loader/PingLoader.h
  350. @@ -0,0 +1,62 @@
  351. +/*
  352. + * Copyright (C) 2010 Google Inc. All rights reserved.
  353. + * Copyright (C) 2017 Apple Inc. All rights reserved.
  354. + *
  355. + * Redistribution and use in source and binary forms, with or without
  356. + * modification, are permitted provided that the following conditions are
  357. + * met:
  358. + *
  359. + *     * Redistributions of source code must retain the above copyright
  360. + * notice, this list of conditions and the following disclaimer.
  361. + *     * Redistributions in binary form must reproduce the above
  362. + * copyright notice, this list of conditions and the following disclaimer
  363. + * in the documentation and/or other materials provided with the
  364. + * distribution.
  365. + *     * Neither the name of Google Inc. nor the names of its
  366. + * contributors may be used to endorse or promote products derived from
  367. + * this software without specific prior written permission.
  368. + *
  369. + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  370. + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  371. + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  372. + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  373. + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  374. + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  375. + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  376. + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  377. + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  378. + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  379. + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  380. + *
  381. + */
  382. +
  383. +#pragma once
  384. +
  385. +#include <wtf/Forward.h>
  386. +#include <wtf/Ref.h>
  387. +
  388. +namespace WebCore {
  389. +
  390. +class FormData;
  391. +class Frame;
  392. +class HTTPHeaderMap;
  393. +class URL;
  394. +class ResourceRequest;
  395. +
  396. +enum class ViolationReportType {
  397. +    ContentSecurityPolicy,
  398. +    XSSAuditor,
  399. +};
  400. +
  401. +class PingLoader {
  402. +public:
  403. +    static void loadImage(Frame&, const URL&);
  404. +    static void sendPing(Frame&, const URL& pingURL, const URL& destinationURL);
  405. +    WEBCORE_EXPORT static void sendViolationReport(Frame&, const URL& reportURL, Ref<FormData>&& report, ViolationReportType);
  406. +
  407. +private:
  408. +    enum class ShouldFollowRedirects { No, Yes };
  409. +    static void startPingLoad(Frame&, ResourceRequest&, HTTPHeaderMap&& originalRequestHeaders, ShouldFollowRedirects);
  410. +};
  411. +
  412. +} // namespace WebCore
  413. diff --git a/Source/WebCore/loader/cache/CachedResourceLoader.cpp b/Source/WebCore/loader/cache/CachedResourceLoader.cpp
  414. index 614cfee9b5..9d3d108113 100644
  415. --- a/Source/WebCore/loader/cache/CachedResourceLoader.cpp
  416. +++ b/Source/WebCore/loader/cache/CachedResourceLoader.cpp
  417. @@ -57,6 +57,7 @@
  418.  #include "Logging.h"
  419.  #include "MemoryCache.h"
  420.  #include "Page.h"
  421. +#include "PingLoader.h"
  422.  #include "PlatformStrategies.h"
  423.  #include "RenderElement.h"
  424.  #include "ResourceLoadInfo.h"
  425. @@ -201,6 +202,8 @@ ResourceErrorOr<CachedResourceHandle<CachedImage>> CachedResourceLoader::request
  426.              if (Document* document = frame->document())
  427.                  request.upgradeInsecureRequestIfNeeded(*document);
  428.              URL requestURL = request.resourceRequest().url();
  429. +            if (requestURL.isValid() && canRequest(CachedResource::Type::ImageResource, requestURL, request, ForPreload::No))
  430. +                PingLoader::loadImage(*frame, requestURL);
  431.              return CachedResourceHandle<CachedImage> { };
  432.          }
  433.      }
  434. diff --git a/Source/WebCore/page/csp/ContentSecurityPolicy.cpp b/Source/WebCore/page/csp/ContentSecurityPolicy.cpp
  435. index f1b1b51da1..9b966fa02b 100644
  436. --- a/Source/WebCore/page/csp/ContentSecurityPolicy.cpp
  437. +++ b/Source/WebCore/page/csp/ContentSecurityPolicy.cpp
  438. @@ -45,6 +45,7 @@
  439.  #include "JSExecState.h"
  440.  #include "JSWindowProxy.h"
  441.  #include "ParsingUtilities.h"
  442. +#include "PingLoader.h"
  443.  #include "ResourceRequest.h"
  444.  #include "RuntimeEnabledFeatures.h"
  445.  #include "SchemeRegistry.h"
  446. @@ -758,6 +759,10 @@ void ContentSecurityPolicy::reportViolation(const String& effectiveViolatedDirec
  447.      if (m_client) {
  448.          for (const auto& url : reportURIs)
  449.              m_client->sendCSPViolationReport(URL { m_protectedURL, url }, report.copyRef());
  450. +    } else {
  451. +        auto& document = downcast<Document>(*m_scriptExecutionContext);
  452. +        for (const auto& url : reportURIs)
  453. +            PingLoader::sendViolationReport(*document.frame(), URL { m_protectedURL, url }, report.copyRef(), ViolationReportType::ContentSecurityPolicy);
  454.      }
  455.  }
  456.  
  457. diff --git a/Source/WebKit/WebProcess/WebPage/WebPage.cpp b/Source/WebKit/WebProcess/WebPage/WebPage.cpp
  458. index e161de3599..5de12b10cc 100644
  459. --- a/Source/WebKit/WebProcess/WebPage/WebPage.cpp
  460. +++ b/Source/WebKit/WebProcess/WebPage/WebPage.cpp
  461. @@ -181,6 +181,7 @@
  462.  #include <WebCore/NotImplemented.h>
  463.  #include <WebCore/Page.h>
  464.  #include <WebCore/PageConfiguration.h>
  465. +#include <WebCore/PingLoader.h>
  466.  #include <WebCore/PlatformKeyboardEvent.h>
  467.  #include <WebCore/PluginDocument.h>
  468.  #include <WebCore/PrintContext.h>
  469. @@ -3358,6 +3359,8 @@ void WebPage::sendCSPViolationReport(uint64_t frameID, const WebCore::URL& repor
  470.      auto report = reportData.takeData();
  471.      if (!report)
  472.          return;
  473. +    if (auto* frame = WebProcess::singleton().webFrame(frameID))
  474. +        PingLoader::sendViolationReport(*frame->coreFrame(), reportURL, report.releaseNonNull(), ViolationReportType::ContentSecurityPolicy);
  475.  }
  476.  
  477.  void WebPage::enqueueSecurityPolicyViolationEvent(uint64_t frameID, SecurityPolicyViolationEvent::Init&& eventInit)
  478. -- 
  479. 2.19.2