PDF: Fix a failing find-in-page corner case.

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 2154 matching lines @@
   }
 
   FPDFText_FindClose(find);
 }
 
 void PDFiumEngine::SearchUsingICU(const base::string16& term,
                                   bool case_sensitive,
                                   bool first_search,
                                   int character_to_start_searching_from,
                                   int current_page) {
-  base::string16 page_text;
-  int text_length = pages_[current_page]->GetCharCount();
+  DCHECK(!term.empty());
+
+  const int original_text_length = pages_[current_page]->GetCharCount();
+  int text_length = original_text_length;
   if (character_to_start_searching_from) {
     text_length -= character_to_start_searching_from;
   } else if (!first_search &&
              last_character_index_to_search_ != -1 &&
              current_page == last_page_to_search_) {
     text_length = last_character_index_to_search_;
   }
   if (text_length <= 0)
     return;
 
+  base::string16 page_text;
   PDFiumAPIStringBufferAdapter<base::string16> api_string_adapter(&page_text,
                                                                   text_length,
                                                                   false);
   unsigned short* data =
       reinterpret_cast<unsigned short*>(api_string_adapter.GetData());
   int written = FPDFText_GetText(pages_[current_page]->GetTextPage(),
                                  character_to_start_searching_from,
                                  text_length,
                                  data);
   api_string_adapter.Close(written);
 
   std::vector<PDFEngine::Client::SearchStringResult> results;
   client_->SearchString(
       page_text.c_str(), term.c_str(), case_sensitive, &results);
   for (const auto& result : results) {
     // Need to map the indexes from the page text, which may have generated
     // characters like space etc, to character indices from the page.
     int temp_start = result.start_index + character_to_start_searching_from;
     int start = FPDFText_GetCharIndexFromTextIndex(
         pages_[current_page]->GetTextPage(), temp_start);
     int end = FPDFText_GetCharIndexFromTextIndex(
         pages_[current_page]->GetTextPage(),
         temp_start + result.length);
+
+    // If |term| occurs at the end of a page, then |end| will be -1 due to the
+    // index being out of bounds. Compensate for this case so the range
+    // character count calculation below works out.
+    if (temp_start + result.length == original_text_length) {
+      DCHECK_EQ(-1, end);
+      end = original_text_length;
+    }
+    DCHECK_LT(start, end);
+    DCHECK_EQ(term.size(), static_cast<size_t>(end - start));
     AddFindResult(PDFiumRange(pages_[current_page].get(), start, end - start));
   }
 }
 
 void PDFiumEngine::AddFindResult(const PDFiumRange& result) {
   // Figure out where to insert the new location, since we could have
   // started searching midway and now we wrapped.
   size_t result_index;
   int page_index = result.page_index();
   int char_index = result.char_index();
@@ skipping 47 matching lines @@
 
   // Update the selection before telling the client to scroll, since it could
   // paint then.
   selection_.clear();
   selection_.push_back(find_results_[current_find_index_.GetIndex()]);
 
   // If the result is not in view, scroll to it.
   pp::Rect bounding_rect;
   pp::Rect visible_rect = GetVisibleRect();
   // Use zoom of 1.0 since visible_rect is without zoom.
-  std::vector<pp::Rect> rects;
-  rects = find_results_[current_find_index_.GetIndex()].GetScreenRects(
-      pp::Point(), 1.0, current_rotation_);
+  std::vector<pp::Rect> rects =
+      find_results_[current_find_index_.GetIndex()].GetScreenRects(
+          pp::Point(), 1.0, current_rotation_);
   for (const auto& rect : rects)
     bounding_rect = bounding_rect.Union(rect);
   if (!visible_rect.Contains(bounding_rect)) {
     pp::Point center = bounding_rect.CenterPoint();
     // Make the page centered.
     int new_y = static_cast<int>(center.y() * current_zoom_) -
         static_cast<int>(visible_rect.height() * current_zoom_ / 2);
     if (new_y < 0)
       new_y = 0;
     client_->ScrollToY(new_y);
@@ skipping 1892 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