PDF: Load linearized files with FPDFAvail_GetDocument().

pdf/pdfium/pdfium_engine.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "pdf/pdfium/pdfium_engine.h"
 
 #include <math.h>
 #include <stddef.h>
 #include <stdint.h>
 
@@ skipping 1095 matching lines @@
 bool PDFiumEngine::IsProgressiveLoad() {
   return doc_loader_.is_partial_document();
 }
 
 std::string PDFiumEngine::GetMetadata(const std::string& key) {
   return GetDocumentMetadata(doc(), key);
 }
 
 void PDFiumEngine::OnPartialDocumentLoaded() {
   file_access_.m_FileLen = doc_loader_.document_size();
-  fpdf_availability_ = FPDFAvail_Create(&file_availability_, &file_access_);
-  DCHECK(fpdf_availability_);
+  if (!fpdf_availability_) {

[Lei Zhang, 2016/01/28 23:17:58]

I haven't checked the possible call orders between OnPartialDocumentLoaded() and
OnDocumentComplete(), so doing this to play it safe.

+    fpdf_availability_ = FPDFAvail_Create(&file_availability_, &file_access_);
+    DCHECK(fpdf_availability_);
+  }
 
   // Currently engine does not deal efficiently with some non-linearized files.
   // See http://code.google.com/p/chromium/issues/detail?id=59400
   // To improve user experience we download entire file for non-linearized PDF.
   if (!FPDFAvail_IsLinearized(fpdf_availability_)) {
     doc_loader_.RequestData(0, doc_loader_.document_size());
     return;
   }
 
   LoadDocument();
@@ skipping 22 matching lines @@
 }
 
 void PDFiumEngine::OnNewDataAvailable() {
   client_->DocumentLoadProgress(doc_loader_.GetAvailableData(),
                                 doc_loader_.document_size());
 }
 
 void PDFiumEngine::OnDocumentComplete() {
   if (!doc_ || !form_) {
     file_access_.m_FileLen = doc_loader_.document_size();
+    if (!fpdf_availability_) {
+      fpdf_availability_ = FPDFAvail_Create(&file_availability_, &file_access_);
+      DCHECK(fpdf_availability_);
+    }
     LoadDocument();
     return;
   }
 
   FinishLoadingDocument();
 }
 
 void PDFiumEngine::FinishLoadingDocument() {
   DCHECK(doc_loader_.IsDocumentComplete() && doc_);
 
@@ skipping 1324 matching lines @@
                                  bool* needs_password) {
   *needs_password = false;
   if (doc_)
     return true;
 
   const char* password_cstr = nullptr;
   if (with_password) {
     password_cstr = password.c_str();
     password_tries_remaining_--;
   }
-  if (doc_loader_.IsDocumentComplete())
+  if (doc_loader_.IsDocumentComplete() &&
+      !FPDFAvail_IsLinearized(fpdf_availability_)) {
     doc_ = FPDF_LoadCustomDocument(&file_access_, password_cstr);
-  else
+  } else {
     doc_ = FPDFAvail_GetDocument(fpdf_availability_, password_cstr);
+  }
 
   if (!doc_ && FPDF_GetLastError() == FPDF_ERR_PASSWORD)
     *needs_password = true;
 
   return !!doc_;
 }
 
 void PDFiumEngine::GetPasswordAndLoad() {
   getting_password_ = true;
   DCHECK(!doc_ && FPDF_GetLastError() == FPDF_ERR_PASSWORD);
@@ skipping 1426 matching lines @@
     double* height) {
   FPDF_DOCUMENT doc = FPDF_LoadMemDocument(pdf_buffer, pdf_buffer_size, NULL);
   if (!doc)
     return false;
   bool success = FPDF_GetPageSizeByIndex(doc, page_number, width, height) != 0;
   FPDF_CloseDocument(doc);
   return success;
 }
 
 }  // namespace chrome_pdf