Remove stl_util's deletion function use from pdf/.

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>
 
 #include <algorithm>
 #include <memory>
 #include <set>
 
 #include "base/i18n/encoding_detection.h"
 #include "base/i18n/icu_string_conversions.h"
 #include "base/lazy_instance.h"
 #include "base/logging.h"
 #include "base/macros.h"
+#include "base/memory/ptr_util.h"
 #include "base/numerics/safe_conversions.h"
 #include "base/stl_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_piece.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "gin/array_buffer.h"
 #include "gin/public/gin_embedders.h"
 #include "gin/public/isolate_holder.h"
 #include "pdf/draw_utils.h"
@@ skipping 617 matching lines @@
     // XFA may require |form_| to outlive |doc_|, so shut down in that order.
     FPDF_CloseDocument(doc_);
     FPDFDOC_ExitFormFillEnvironment(form_);
 #else
     // Normally |doc_| should outlive |form_|.
     FPDFDOC_ExitFormFillEnvironment(form_);
     FPDF_CloseDocument(doc_);
 #endif
   }
   FPDFAvail_Destroy(fpdf_availability_);
-
-  base::STLDeleteElements(&pages_);
 }
 
 #if defined(PDF_ENABLE_XFA)
 
 void PDFiumEngine::Form_EmailTo(FPDF_FORMFILLINFO* param,
                                 FPDF_FILEHANDLER* file_handler,
                                 FPDF_WIDESTRING to,
                                 FPDF_WIDESTRING subject,
                                 FPDF_WIDESTRING cc,
                                 FPDF_WIDESTRING bcc,
@@ skipping 931 matching lines @@
   } else if (event.GetClickCount() == 2 ||
              event.GetClickCount() == 3) {
     OnMultipleClick(event.GetClickCount(), page_index, char_index);
   }
 
   return true;
 }
 
 void PDFiumEngine::OnSingleClick(int page_index, int char_index) {
   SetSelecting(true);
-  selection_.push_back(PDFiumRange(pages_[page_index], char_index, 0));
+  selection_.push_back(PDFiumRange(pages_[page_index].get(), char_index, 0));
 }
 
 void PDFiumEngine::OnMultipleClick(int click_count,
                                    int page_index,
                                    int char_index) {
   // It would be more efficient if the SDK could support finding a space, but
   // now it doesn't.
   int start_index = char_index;
   do {
     base::char16 cur = pages_[page_index]->GetCharAtIndex(start_index);
     // For double click, we want to select one word so we look for whitespace
     // boundaries.  For triple click, we want the whole line.
     if (cur == '\n' || (click_count == 2 && (cur == ' ' || cur == '\t')))
       break;
   } while (--start_index >= 0);
   if (start_index)
     start_index++;
 
   int end_index = char_index;
   int total = pages_[page_index]->GetCharCount();
   while (end_index++ <= total) {
     base::char16 cur = pages_[page_index]->GetCharAtIndex(end_index);
     if (cur == '\n' || (click_count == 2 && (cur == ' ' || cur == '\t')))
       break;
   }
 
-  selection_.push_back(PDFiumRange(
-      pages_[page_index], start_index, end_index - start_index));
+  selection_.push_back(PDFiumRange(pages_[page_index].get(), start_index,
+                                   end_index - start_index));
 }
 
 bool PDFiumEngine::OnMouseUp(const pp::MouseInputEvent& event) {
   if (event.GetButton() != PP_INPUTEVENT_MOUSEBUTTON_LEFT &&
       event.GetButton() != PP_INPUTEVENT_MOUSEBUTTON_MIDDLE) {
     return false;
   }
 
   int page_index = -1;
   int char_index = -1;
@@ skipping 135 matching lines @@
     } else {
       count = char_index - selection_[last].char_index() - 1;
     }
     selection_[last].SetCharCount(count);
   } else if (selection_[last].page_index() < page_index) {
     // Selecting into the next page.
 
     // First make sure that there are no gaps in selection, i.e. if mousedown on
     // page one but we only get mousemove over page three, we want page two.
     for (int i = selection_[last].page_index() + 1; i < page_index; ++i) {
-      selection_.push_back(PDFiumRange(pages_[i], 0,
-                           pages_[i]->GetCharCount()));
+      selection_.push_back(
+          PDFiumRange(pages_[i].get(), 0, pages_[i]->GetCharCount()));
     }
 
     int count = pages_[selection_[last].page_index()]->GetCharCount();
     selection_[last].SetCharCount(count - selection_[last].char_index());
-    selection_.push_back(PDFiumRange(pages_[page_index], 0, char_index));
+    selection_.push_back(PDFiumRange(pages_[page_index].get(), 0, char_index));
   } else {
     // Selecting into the previous page.
     // The selection's char_index is 0-based, so the character count is one
     // more than the index. The character count needs to be negative to
     // indicate a backwards selection.
     selection_[last].SetCharCount(-(selection_[last].char_index() + 1));
 
     // First make sure that there are no gaps in selection, i.e. if mousedown on
     // page three but we only get mousemove over page one, we want page two.
     for (int i = selection_[last].page_index() - 1; i > page_index; --i) {
-      selection_.push_back(PDFiumRange(pages_[i], 0,
-                           pages_[i]->GetCharCount()));
+      selection_.push_back(
+          PDFiumRange(pages_[i].get(), 0, pages_[i]->GetCharCount()));
     }
 
     int count = pages_[page_index]->GetCharCount();
     selection_.push_back(
-        PDFiumRange(pages_[page_index], count, count - char_index));
+        PDFiumRange(pages_[page_index].get(), count, count - char_index));
   }
 
   return true;
 }
 
 bool PDFiumEngine::OnKeyDown(const pp::KeyboardInputEvent& event) {
   if (last_page_mouse_down_ == -1)
     return false;
 
   bool rv = !!FORM_OnKeyDown(
@@ skipping 144 matching lines @@
   unsigned long flags = case_sensitive ? FPDF_MATCHCASE : 0;
   FPDF_SCHHANDLE find = FPDFText_FindStart(
       pages_[current_page]->GetTextPage(),
       reinterpret_cast<const unsigned short*>(term.c_str()),
       flags, character_to_start_searching_from);
 
   // Note: since we search one page at a time, we don't find matches across
   // page boundaries.  We could do this manually ourself, but it seems low
   // priority since Reader itself doesn't do it.
   while (FPDFText_FindNext(find)) {
-    PDFiumRange result(pages_[current_page],
+    PDFiumRange result(pages_[current_page].get(),
                        FPDFText_GetSchResultIndex(find),
                        FPDFText_GetSchCount(find));
 
     if (!first_search &&
         last_character_index_to_search_ != -1 &&
         result.page_index() == last_page_to_search_ &&
         result.char_index() >= last_character_index_to_search_) {
       break;
     }
 
@@ skipping 36 matching lines @@
       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);
-    AddFindResult(PDFiumRange(pages_[current_page], start, 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();
   for (result_index = 0; result_index < find_results_.size(); ++result_index) {
@@ skipping 207 matching lines @@
       return true;
   }
 }
 
 void PDFiumEngine::SelectAll() {
   SelectionChangeInvalidator selection_invalidator(this);
 
   selection_.clear();
   for (const auto& page : pages_) {
     if (page->available())
-      selection_.push_back(PDFiumRange(page, 0, page->GetCharCount()));
+      selection_.push_back(PDFiumRange(page.get(), 0, page->GetCharCount()));
   }
 }
 
 int PDFiumEngine::GetNumberOfPages() {
   return pages_.size();
 }
 
 pp::VarArray PDFiumEngine::GetBookmarks() {
   pp::VarDictionary dict = TraverseBookmarks(doc_, nullptr, 0);
   // The root bookmark contains no useful information.
@@ skipping 121 matching lines @@
   DCHECK_NE(num_pages, 0);
 
   if (!doc_)
     return;
 
   selection_.clear();
   pending_pages_.clear();
 
   // Delete all pages except the first one.
   while (pages_.size() > 1) {
-    delete pages_.back();
     pages_.pop_back();
     FPDFPage_Delete(doc_, pages_.size());
   }
 
   // Calculate document size and all page sizes.
   std::vector<pp::Rect> page_rects;
   pp::Size page_size = GetPageSize(0);
   page_size.Enlarge(kPageShadowLeft + kPageShadowRight,
                     kPageShadowTop + kPageShadowBottom);
   pp::Size old_document_size = document_size_;
@@ skipping 15 matching lines @@
     pp::Rect page_rect(page_rects[i]);
     page_rect.Inset(kPageShadowLeft, kPageShadowTop,
                     kPageShadowRight, kPageShadowBottom);
     double width_in_points = ConvertUnitDouble(page_rect.width(),
                                                kPixelsPerInch,
                                                kPointsPerInch);
     double height_in_points = ConvertUnitDouble(page_rect.height(),
                                                 kPixelsPerInch,
                                                 kPointsPerInch);
     FPDFPage_New(doc_, i, width_in_points, height_in_points);
-    pages_.push_back(new PDFiumPage(this, i, page_rect, true));
+    pages_.push_back(base::MakeUnique<PDFiumPage>(this, i, page_rect, true));
   }
 
   CalculateVisiblePages();
   if (document_size_ != old_document_size)
     client_->DocumentSizeUpdated(document_size_);
 }
 
 void PDFiumEngine::LoadDocument() {
   // Check if the document is ready for loading. If it isn't just bail for now,
   // we will call LoadDocument() again later.
@@ skipping 172 matching lines @@
     page_rects[i].set_x((document_size_.width() - page_rects[i].width()) / 2);
     pp::Rect page_rect(page_rects[i]);
     page_rect.Inset(kPageShadowLeft, kPageShadowTop,
                     kPageShadowRight, kPageShadowBottom);
     if (reload) {
       pages_[i]->set_rect(page_rect);
     } else {
       // The page is marked as not being available even if |doc_complete| is
       // true because FPDFAvail_IsPageAvail() still has to be called for this
       // page, which will be done in FinishLoadingDocument().
-      pages_.push_back(new PDFiumPage(this, i, page_rect, false));
+      pages_.push_back(base::MakeUnique<PDFiumPage>(this, i, page_rect, false));
     }
   }
 
   CalculateVisiblePages();
   if (document_size_ != old_document_size)
     client_->DocumentSizeUpdated(document_size_);
 }
 
 void PDFiumEngine::CalculateVisiblePages() {
   // Clear pending requests queue, since it may contain requests to the pages
@@ skipping 1359 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