Do not load main cross refs for first page in linearized pdf.

fpdfsdk/fpdf_dataavail_embeddertest.cpp

 // Copyright 2015 PDFium 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 <algorithm>
 #include <memory>
 #include <string>
 #include <vector>
 
 #include "public/fpdfview.h"
@@ skipping 27 matching lines @@
   bool IsOpened() const { return !!file_contents_; }
 
   FPDF_FILEACCESS* file_access() { return &file_access_; }
   FX_DOWNLOADHINTS* hints() { return this; }
   FX_FILEAVAIL* file_avail() { return this; }
 
   const std::vector<std::pair<size_t, size_t>>& requested_segments() const {
     return requested_segments_;
   }
 
-  void ClearRequestedSegments() { requested_segments_.clear(); }
+  size_t max_requested_bound() const { return max_requested_bound_; }
+
+  void ClearRequestedSegments() {
+    requested_segments_.clear();
+    max_requested_bound_ = 0;
+  }
 
   bool is_new_data_available() const { return is_new_data_available_; }
   void set_is_new_data_available(bool is_new_data_available) {
     is_new_data_available_ = is_new_data_available;
   }
 
+  size_t max_already_available_bound() const {
+    return available_ranges_.empty() ? 0 : available_ranges_.rbegin()->second;
+  }
+
  private:
   void SetDataAvailable(size_t start, size_t size) {
     if (size == 0)
       return;
     const auto range = std::make_pair(start, start + size);
     if (available_ranges_.empty()) {
       available_ranges_.insert(range);
       return;
     }
     auto start_it = available_ranges_.upper_bound(range);
@@ skipping 37 matching lines @@
         std::min(static_cast<unsigned long>(file_length_), pos + size);
     if (end <= pos)
       return 0;
     memcpy(pBuf, file_contents_.get() + pos, end - pos);
     SetDataAvailable(pos, end - pos);
     return static_cast<int>(end - pos);
   }
 
   void AddSegmentImpl(size_t offset, size_t size) {
     requested_segments_.push_back(std::make_pair(offset, size));
+    max_requested_bound_ = std::max(max_requested_bound_, offset + size);
   }
 
   bool IsDataAvailImpl(size_t offset, size_t size) {
     if (offset + size > file_length_)
       return false;
     if (is_new_data_available_) {
       SetDataAvailable(offset, size);
       return true;
     }
     return CheckDataAlreadyAvailable(offset, size);
@@ skipping 14 matching lines @@
                                 size_t offset,
                                 size_t size) {
     return static_cast<TestAsyncLoader*>(pThis)->IsDataAvailImpl(offset, size);
   }
 
   FPDF_FILEACCESS file_access_;
 
   std::unique_ptr<char, pdfium::FreeDeleter> file_contents_;
   size_t file_length_;
   std::vector<std::pair<size_t, size_t>> requested_segments_;
+  size_t max_requested_bound_ = 0;
   bool is_new_data_available_ = true;
 
   using Range = std::pair<size_t, size_t>;
   struct range_compare {
     bool operator()(const Range& lval, const Range& rval) const {
       return lval.first < rval.first;
     }
   };
   using RangesContainer = std::set<Range, range_compare>;
   RangesContainer available_ranges_;
@@ skipping 22 matching lines @@
   document_ = FPDFAvail_GetDocument(avail_, nullptr);
   ASSERT_TRUE(document_);
   ASSERT_EQ(PDF_DATA_AVAIL, FPDFAvail_IsPageAvail(avail_, 1, loader.hints()));
 
   // No new data available, to prevent load "Pages" node.
   loader.set_is_new_data_available(false);
   FPDF_PAGE page = LoadPage(1);
   EXPECT_TRUE(page);
   UnloadPage(page);
 }
+
+TEST_F(FPDFDataAvailEmbeddertest,
+       DoNotLoadMainCrossRefForFirstPageIfLinearized) {
+  TestAsyncLoader loader("feature_linearized_loading.pdf");
+  avail_ = FPDFAvail_Create(loader.file_avail(), loader.file_access());
+  ASSERT_EQ(PDF_DATA_AVAIL, FPDFAvail_IsDocAvail(avail_, loader.hints()));
+  document_ = FPDFAvail_GetDocument(avail_, nullptr);
+  ASSERT_TRUE(document_);
+  const int first_page_num = FPDFAvail_GetFirstPageNum(document_);
+
+  // The main cross ref table should not be processed.
+  // (It is always at file end)
+  EXPECT_GT(loader.file_access()->m_FileLen,
+            loader.max_already_available_bound());
+
+  // Prevent access to non requested data to coerce the parser to send new
+  // request for non available (non requested before) data.
+  loader.set_is_new_data_available(false);
+  FPDFAvail_IsPageAvail(avail_, first_page_num, loader.hints());
+
+  // The main cross ref table should not be requested.
+  // (It is always at file end)
+  EXPECT_GT(loader.file_access()->m_FileLen, loader.max_requested_bound());
+
+  // Allow parse page.
+  loader.set_is_new_data_available(true);
+  ASSERT_EQ(PDF_DATA_AVAIL,
+            FPDFAvail_IsPageAvail(avail_, first_page_num, loader.hints()));
+
+  // The main cross ref table should not be processed.
+  // (It is always at file end)
+  EXPECT_GT(loader.file_access()->m_FileLen,
+            loader.max_already_available_bound());
+
+  // Prevent loading data, while page loading.
+  loader.set_is_new_data_available(false);
+  FPDF_PAGE page = LoadPage(first_page_num);
+  EXPECT_TRUE(page);
+  UnloadPage(page);
+}