Changeset 259760 in webkit

Timestamp:

Apr 8, 2020, 3:15:16 PM (6 years ago)

Author:

beidson@apple.com

Message:

Fix handling non-linearized PDFs when incremental PDF loading is enabled.
<rdar://problem/60619506> and ​https://bugs.webkit.org/show_bug.cgi?id=210208

Reviewed by Tim Horton (and I think Geoff Garen, probably. It's confusing.)

When we try to load a non-linearized PDF with PDFKit, it makes an outlandishly large range request
to try to verify the PDF file size.

That's covered by <rdar://problem/61473378>

Meanwhile we need to detect that and fallback to non-incremental PDF loading.

• WebProcess/Plugins/PDF/PDFPlugin.h:
• WebProcess/Plugins/PDF/PDFPlugin.mm:

(WebKit::PDFPlugin::receivedInvalidRangeRequest):
(WebKit::dataProviderGetBytesAtPositionCallback):
(WebKit::PDFPlugin::threadEntry):
(WebKit::PDFPlugin::installPDFDocument):

Location:

trunk/Source/WebKit

Files:

• ChangeLog (modified) (1 diff)
• WebProcess/Plugins/PDF/PDFPlugin.h (modified) (1 diff)
• WebProcess/Plugins/PDF/PDFPlugin.mm (modified) (7 diffs)

trunk/Source/WebKit/ChangeLog

@@ +1 @@
+2020-04-08  Brady Eidson  <beidson@apple.com>
+
+        Fix handling non-linearized PDFs when incremental PDF loading is enabled.
+        <rdar://problem/60619506> and https://bugs.webkit.org/show_bug.cgi?id=210208
+
+        Reviewed by Tim Horton (and I think Geoff Garen, probably. It's confusing.)
+
+        When we try to load a non-linearized PDF with PDFKit, it makes an outlandishly large range request
+        to try to verify the PDF file size.
+        
+        That's covered by <rdar://problem/61473378>
+        
+        Meanwhile we need to detect that and fallback to non-incremental PDF loading.
+
+        * WebProcess/Plugins/PDF/PDFPlugin.h:
+        * WebProcess/Plugins/PDF/PDFPlugin.mm:
+        (WebKit::PDFPlugin::receivedInvalidRangeRequest):
+        (WebKit::dataProviderGetBytesAtPositionCallback):
+        (WebKit::PDFPlugin::threadEntry):
+        (WebKit::PDFPlugin::installPDFDocument):
+
 2020-04-08  Per Arne Vollan  <pvollan@apple.com>
 

trunk/Source/WebKit/WebProcess/Plugins/PDF/PDFPlugin.h

@@ -136 +136 @@
     void getResourceBytesAtPosition(size_t count, off_t position, CompletionHandler<void(const uint8_t*, size_t count)>&&);
     size_t getResourceBytesAtPositionMainThread(void* buffer, off_t position, size_t count);
+    void receivedNonLinearizedPDFSentinel();
+    bool incrementalPDFLoadingEnabled() const { return m_incrementalPDFLoadingEnabled; }
 #ifndef NDEBUG
     void pdfLog(const String& event);

trunk/Source/WebKit/WebProcess/Plugins/PDF/PDFPlugin.mm

@@ -91 +91 @@
 #import <pal/spi/mac/NSMenuSPI.h>
 #import <wtf/HexNumber.h>
+#import <wtf/Scope.h>
 #import <wtf/UUID.h>
 #import <wtf/WTFSemaphore.h>
@@ -137 +138 @@
 static const int defaultScrollMagnitudeThresholdForPageFlip = 20;
 
+// <rdar://problem/61473378> - PDFKit asks for a "way too large" range when the PDF it is loading
+// incrementally turns out to be non-linearized.
+// We'll assume any size over 4gb is PDFKit noticing non-linearized data.
+static const uint32_t nonLinearizedPDFSentinel = std::numeric_limits<uint32_t>::max();
+
 @interface WKPDFPluginAccessibilityObject : NSObject {
     PDFLayerController *_pdfLayerController;
@@ -694 +700 @@
 #endif // !LOG_DISABLED
 
+void PDFPlugin::receivedNonLinearizedPDFSentinel()
+{
+    m_incrementalPDFLoadingEnabled = false;
+
+    if (!isMainThread()) {
+#if !LOG_DISABLED
+        pdfLog("Disabling incremental PDF loading on background thread");
+#endif
+        callOnMainThread([this, protectedThis = makeRef(*this)] {
+            receivedNonLinearizedPDFSentinel();
+        });
+        return;
+    }
+
+#if !LOG_DISABLED
+    pdfLog(makeString("Cancelling all ", m_streamLoaderMap.size(), " range request loaders"));
+#endif
+
+    for (auto iterator = m_streamLoaderMap.begin(); iterator != m_streamLoaderMap.end(); iterator = m_streamLoaderMap.begin()) {
+        m_outstandingByteRangeRequests.remove(iterator->value);
+        cancelAndForgetLoader(*iterator->key);
+    }
+
+    if (!m_documentFinishedLoading || m_pdfDocument)
+        return;
+
+    m_pdfDocument = adoptNS([[pdfDocumentClass() alloc] initWithData:rawData()]);
+    installPDFDocument();
+    tryRunScriptsInPDFDocument();
+}
+
 static size_t dataProviderGetBytesAtPositionCallback(void* info, void* buffer, off_t position, size_t count)
 {
+    Ref<PDFPlugin> plugin = *((PDFPlugin*)info);
+
     if (isMainThread()) {
 #if !LOG_DISABLED
-        ((PDFPlugin*)info)->pdfLog(makeString("Handling request for ", count, " bytes at position ", position, " synchronously on the main thread"));
+        plugin->pdfLog(makeString("Handling request for ", count, " bytes at position ", position, " synchronously on the main thread"));
 #endif
-        return ((PDFPlugin*)info)->getResourceBytesAtPositionMainThread(buffer, position, count);
-    }
+        return plugin->getResourceBytesAtPositionMainThread(buffer, position, count);
+    }
+
+    // It's possible we previously encountered an invalid range and therefore disabled incremental loading,
+    // but PDFDocument is still trying to read data using a different strategy.
+    // Always ignore such requests.
+    if (!plugin->incrementalPDFLoadingEnabled())
+        return 0;
 
 #if !LOG_DISABLED
-    Ref<PDFPlugin> debugPluginRef = *((PDFPlugin*)info);
+    auto debugPluginRef = plugin.copyRef();
     debugPluginRef->incrementThreadsWaitingOnCallback();
     debugPluginRef->pdfLog(makeString("PDF data provider requesting ", count, " bytes at position ", position));
 #endif
 
-    Ref<PDFPlugin> plugin = *((PDFPlugin*)info);
+    if (position > nonLinearizedPDFSentinel) {
+#if !LOG_DISABLED
+        plugin->pdfLog(makeString("Received invalid range request for ", count, " bytes at position ", position, ". PDF is probably not linearized. Falling back to non-incremental loading."));
+#endif
+        plugin->receivedNonLinearizedPDFSentinel();
+        return 0;
+    }
+
     WTF::Semaphore dataSemaphore { 0 };
     size_t bytesProvided = 0;
@@ -803 +855 @@
     };
 
+    auto scopeExit = makeScopeExit([protectedPlugin = WTFMove(protectedPlugin)] () mutable {
+        // Keep the PDFPlugin alive until the end of this function and the end
+        // of the last main thread task submitted by this function.
+        callOnMainThread([protectedPlugin = WTFMove(protectedPlugin)] { });
+    });
+
     // Balanced by a deref inside of the dataProviderReleaseInfoCallback
     ref();
@@ -810 +868 @@
     m_backgroundThreadDocument = adoptNS([[pdfDocumentClass() alloc] initWithProvider:dataProvider.get()]);
 
+    if (!m_incrementalPDFLoadingEnabled) {
+        m_backgroundThreadDocument = nil;
+        return;
+    }
+
     WTF::Semaphore firstPageSemaphore { 0 };
     auto firstPageQueue = WorkQueue::create("PDF first page work queue");
 
     [m_backgroundThreadDocument preloadDataOfPagesInRange:NSMakeRange(0, 1) onQueue:firstPageQueue->dispatchQueue() completion:[&firstPageSemaphore, this] (NSIndexSet *) mutable {
-        callOnMainThread([this] {
-            adoptBackgroundThreadDocument();
-        });
+        if (m_incrementalPDFLoadingEnabled) {
+            callOnMainThread([this] {
+                adoptBackgroundThreadDocument();
+            });
+        } else
+            m_backgroundThreadDocument = nil;
+
         firstPageSemaphore.signal();
     }];
@@ -825 +892 @@
     pdfLog("Finished preloading first page");
 #endif
-
-    // The main thread dispatch below removes the last reference to the PDF thread.
-    // It must be the last code executed in this function.
-    callOnMainThread([protectedPlugin = WTFMove(protectedPlugin)] { });
 }
 
@@ -1470 +1533 @@
     ASSERT(m_pdfDocument);
     ASSERT(isMainThread());
+    LOG(IncrementalPDF, "Installing PDF document");
 
 #if HAVE(INCREMENTAL_PDF_APIS)