Get the correct page size for linearized PDFs.

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 2504 matching lines @@
     FinishLoadingDocument();
 }
 
 void PDFiumEngine::LoadPageInfo(bool reload) {
   pending_pages_.clear();
   pp::Size old_document_size = document_size_;
   document_size_ = pp::Size();
   std::vector<pp::Rect> page_rects;
   int page_count = FPDF_GetPageCount(doc_);
   bool doc_complete = doc_loader_.IsDocumentComplete();
+  bool is_linear = FPDFAvail_IsLinearized(fpdf_availability_) == PDF_LINEARIZED;
   for (int i = 0; i < page_count; ++i) {
     if (i != 0) {
       // Add space for horizontal separator.
       document_size_.Enlarge(0, kPageSeparatorThickness);
     }
 
-    // Get page availability. If reload==false, and document is not loaded yet
-    // (we are using async loading) - mark all pages as unavailable.
-    // If reload==true (we have document constructed already), get page
-    // availability flag from already existing PDFiumPage class.
-    bool page_available = reload ? pages_[i]->available() : doc_complete;
+    // Get page availability. If |reload| == true, then the document has been
+    // constructed already. Get page availability flag from already existing
+    // PDFiumPage class.
+    // If |reload| == false, then the document may not be fully loaded yet.
+    bool page_available;
+    if (reload) {
+      page_available = pages_[i]->available();
+    } else if (is_linear) {
+      int linear_page_avail =
+          FPDFAvail_IsPageAvail(fpdf_availability_, i, &download_hints_);
+      page_available = linear_page_avail == PDF_DATA_AVAIL;
+    } else {
+      page_available = doc_complete;
+    }
 
     pp::Size size = page_available ? GetPageSize(i) : default_page_size_;
     size.Enlarge(kPageShadowLeft + kPageShadowRight,
                  kPageShadowTop + kPageShadowBottom);
     pp::Rect rect(pp::Point(0, document_size_.height()), size);
     page_rects.push_back(rect);
 
     if (size.width() > document_size_.width())
       document_size_.set_width(size.width());
 
@@ skipping 79 matching lines @@
 
 bool PDFiumEngine::CheckPageAvailable(int index, std::vector<int>* pending) {
   if (!doc_ || !form_)
     return false;
 
   const int num_pages = static_cast<int>(pages_.size());
   if (index < num_pages && pages_[index]->available())
     return true;
 
   if (!FPDFAvail_IsPageAvail(fpdf_availability_, index, &download_hints_)) {
-    size_t j;
-    for (j = 0; j < pending->size(); ++j) {
-      if ((*pending)[j] == index)
-        break;
-    }
-
-    if (j == pending->size())
+    if (!ContainsValue(*pending, index))
       pending->push_back(index);
     return false;
   }
 
   if (index < num_pages)
     pages_[index]->set_available(true);
   if (!default_page_size_.GetArea())
     default_page_size_ = GetPageSize(index);
   return true;
 }
@@ skipping 1221 matching lines @@
   FPDF_DOCUMENT doc =
       FPDF_LoadMemDocument(pdf_buffer, pdf_buffer_size, nullptr);
   if (!doc)
     return false;
   bool success = FPDF_GetPageSizeByIndex(doc, page_number, width, height) != 0;
   FPDF_CloseDocument(doc);
   return success;
 }
 
 }  // namespace chrome_pdf