Allows the PDF engine return the page index it is scrolling to

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 2265 matching lines @@
         reinterpret_cast<FPDF_WIDESTRING>(destination_wide.c_str());
     FPDF_BOOKMARK bookmark = FPDFBookmark_Find(doc_, destination_pdf_wide);
     if (!bookmark)
       return -1;
     dest = FPDFBookmark_GetDest(doc_, bookmark);
   }
   return dest ? FPDFDest_GetPageIndex(doc_, dest) : -1;
 }
 
 int PDFiumEngine::GetMostVisiblePage() {
+  if (in_flight_visible_page_)
+    return *in_flight_visible_page_;
+
   CalculateVisiblePages();
   return most_visible_page_;
 }
 
 pp::Rect PDFiumEngine::GetPageRect(int index) {
   pp::Rect rc(pages_[index]->rect());
   rc.Inset(-kPageShadowLeft, -kPageShadowTop,
            -kPageShadowRight, -kPageShadowBottom);
   return rc;
 }
@@ skipping 374 matching lines @@
       most_visible_page++;
   }
 
   SetCurrentPage(most_visible_page);
 }
 
 bool PDFiumEngine::IsPageVisible(int index) const {
   return base::ContainsValue(visible_pages_, index);
 }
 
+void PDFiumEngine::ScrollToPage(int page) {
+  in_flight_visible_page_ = page;
+  client_->ScrollToPage(page);
+}
+
 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_)) {
     if (!base::ContainsValue(*pending, index))
@@ skipping 486 matching lines @@
 
 int PDFiumEngine::GetVisiblePageIndex(FPDF_PAGE page) {
   for (int page_index : visible_pages_) {
     if (pages_[page_index]->GetPage() == page)
       return page_index;
   }
   return -1;
 }
 
 void PDFiumEngine::SetCurrentPage(int index) {
+  in_flight_visible_page_.reset();
+
   if (index == most_visible_page_ || !form_)
     return;
 
   if (most_visible_page_ != -1 && called_do_document_action_) {
     FPDF_PAGE old_page = pages_[most_visible_page_]->GetPage();
     FORM_DoPageAAction(old_page, form_, FPDFPAGE_AACTION_CLOSE);
   }
   most_visible_page_ = index;
 #if defined(OS_LINUX)
     g_last_instance_id = client_->GetPluginInstance()->pp_instance();
@@ skipping 323 matching lines @@
   if (index == -1)
     index = engine->GetMostVisiblePage();
   */
   if (index == -1)
     return;
 
   // This is the only list of named actions per the spec (see 12.6.4.11). Adobe
   // Reader supports more, like FitWidth, but since they're not part of the spec
   // and we haven't got bugs about them, no need to now.
   if (action == "NextPage") {
-    engine->client_->ScrollToPage(index + 1);
+    engine->ScrollToPage(index + 1);
   } else if (action == "PrevPage") {
-    engine->client_->ScrollToPage(index - 1);
+    engine->ScrollToPage(index - 1);
   } else if (action == "FirstPage") {
-    engine->client_->ScrollToPage(0);
+    engine->ScrollToPage(0);
   } else if (action == "LastPage") {
-    engine->client_->ScrollToPage(engine->pages_.size() - 1);
+    engine->ScrollToPage(engine->pages_.size() - 1);
   }
 }
 
 void PDFiumEngine::Form_SetTextFieldFocus(FPDF_FORMFILLINFO* param,
                                           FPDF_WIDESTRING value,
                                           FPDF_DWORD valueLen,
                                           FPDF_BOOL is_focus) {
   // Do nothing for now.
   // TODO(gene): use this signal to trigger OSK.
 }
 
 void PDFiumEngine::Form_DoURIAction(FPDF_FORMFILLINFO* param,
                                     FPDF_BYTESTRING uri) {
   PDFiumEngine* engine = static_cast<PDFiumEngine*>(param);
   engine->client_->NavigateTo(std::string(uri), CURRENT_TAB);
 }
 
 void PDFiumEngine::Form_DoGoToAction(FPDF_FORMFILLINFO* param,
                                      int page_index,
                                      int zoom_mode,
                                      float* position_array,
                                      int size_of_array) {
   PDFiumEngine* engine = static_cast<PDFiumEngine*>(param);
-  engine->client_->ScrollToPage(page_index);
+  engine->ScrollToPage(page_index);
 }
 
 int PDFiumEngine::Form_Alert(IPDF_JSPLATFORM* param,
                              FPDF_WIDESTRING message,
                              FPDF_WIDESTRING title,
                              int type,
                              int icon) {
   // See fpdfformfill.h for these values.
   enum AlertType {
     ALERT_TYPE_OK = 0,
@@ skipping 108 matching lines @@
                                    FPDF_WIDESTRING url) {
   std::string url_str =
       base::UTF16ToUTF8(reinterpret_cast<const base::char16*>(url));
   PDFiumEngine* engine = static_cast<PDFiumEngine*>(param);
   engine->client_->SubmitForm(url_str, form_data, length);
 }
 
 void PDFiumEngine::Form_GotoPage(IPDF_JSPLATFORM* param,
                                  int page_number) {
   PDFiumEngine* engine = static_cast<PDFiumEngine*>(param);
-  engine->client_->ScrollToPage(page_number);
+  engine->ScrollToPage(page_number);
 }
 
 int PDFiumEngine::Form_Browse(IPDF_JSPLATFORM* param,
                               void* file_path,
                               int length) {
   PDFiumEngine* engine = static_cast<PDFiumEngine*>(param);
   std::string path = engine->client_->ShowFileSelectionDialog();
   if (path.size() + 1 <= static_cast<size_t>(length))
     memcpy(file_path, &path[0], path.size() + 1);
   return path.size() + 1;
@@ skipping 262 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