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_);

[Lei Zhang, 2016/11/09 08:51:12]

Might as well check the result since we have it?

[snake, 2016/11/09 12:41:49]

We always should have it. For this test is not matter, what value of this.

+
+  // 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());
+
+  // No new data available, to took the download request.

[Lei Zhang, 2016/11/09 08:51:12]

"to took the download request" doesn't parse.

[snake, 2016/11/09 12:41:49]

Done.

+  loader.set_is_new_data_available(false);
+  FPDFAvail_IsPageAvail(avail_, first_page_num, loader.hints());

[Lei Zhang, 2016/11/09 08:51:12]

Do you care about the return value?

[snake, 2016/11/09 12:41:49]

No. For first call this is not matter. (Currently the first page availability is
checked as part of document availability check, and on first call it is already
available, but this can be changed in future and not related to this test). But
on second call it is should be available always (in this test case).

+
+  // 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);
+}