Another round of PDF plugin cleanups.

pdf/pdfium/pdfium_page.cc

 // Copyright (c) 2010 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_page.h"
 
 #include <math.h>
 #include <stddef.h>
 
 #include "base/logging.h"
@@ skipping 157 matching lines @@
   FPDF_LINK link = FPDFLink_GetLinkAtPoint(GetPage(), left, top);
   Area area;
   std::vector<LinkTarget> targets;
   if (link) {
     targets.push_back(LinkTarget());
     area = GetLinkTarget(link, &targets[0]);
   } else {
     pp::Rect rect(
         PageToScreen(pp::Point(), 1.0, left, top, right, bottom, rotation));
     GetLinks(rect, &targets);
-    area = targets.size() == 0 ? TEXT_AREA : WEBLINK_AREA;
+    area = targets.empty() ? TEXT_AREA : WEBLINK_AREA;
   }
 
   int char_index = FPDFText_GetCharIndexAtPos(GetTextPage(), left, top,
                                               kTolerance, kTolerance);
   double font_size = FPDFText_GetFontSize(GetTextPage(), char_index);
 
   base::DictionaryValue* node = new base::DictionaryValue();
   node->SetDouble(kTextBoxLeft, left);
   node->SetDouble(kTextBoxTop, page_height - top);
   node->SetDouble(kTextBoxWidth, right - left);
   node->SetDouble(kTextBoxHeight, top - bottom);
   node->SetDouble(kTextBoxFontSize, font_size);
 
   base::ListValue* text_nodes = new base::ListValue();
 
   if (area == DOCLINK_AREA) {
     std::string url = kDocLinkURLPrefix + base::IntToString(targets[0].page);
     text_nodes->Append(CreateURLNode(text_utf8, url));
   } else if (area == WEBLINK_AREA && link) {
     text_nodes->Append(CreateURLNode(text_utf8, targets[0].url));
   } else if (area == WEBLINK_AREA && !link) {
     size_t start = 0;
-    for (size_t i = 0; i < targets.size(); ++i) {
+    for (const auto& target : targets) {
       // If there is an extra NULL character at end, find() will not return any
       // matches. There should not be any though.
-      if (!targets[i].url.empty())
-        DCHECK(targets[i].url[targets[i].url.size() - 1] != '\0');
+      if (!target.url.empty())
+        DCHECK_NE(target.url.back(), '\0');
 
       // PDFium may change the case of generated links.
-      std::string lowerCaseURL = base::ToLowerASCII(targets[i].url);
+      std::string lowerCaseURL = base::ToLowerASCII(target.url);
       std::string lowerCaseText = base::ToLowerASCII(text_utf8);
       size_t pos = lowerCaseText.find(lowerCaseURL, start);
-      size_t length = targets[i].url.size();
+      size_t length = target.url.size();
       if (pos == std::string::npos) {
         // Check if the link is a "mailto:" URL
         if (lowerCaseURL.compare(0, 7, "mailto:") == 0) {
           pos = lowerCaseText.find(lowerCaseURL.substr(7), start);
           length -= 7;
         }
 
         if (pos == std::string::npos) {
           // No match has been found.  This should never happen.
           continue;
         }
       }
 
       std::string before_text = text_utf8.substr(start, pos - start);
-      if (before_text.size() > 0)
+      if (!before_text.empty())
         text_nodes->Append(CreateTextNode(before_text));
       std::string link_text = text_utf8.substr(pos, length);
-      text_nodes->Append(CreateURLNode(link_text, targets[i].url));
+      text_nodes->Append(CreateURLNode(link_text, target.url));
 
       start = pos + length;
     }
     std::string before_text = text_utf8.substr(start);
-    if (before_text.size() > 0)
+    if (!before_text.empty())
       text_nodes->Append(CreateTextNode(before_text));
   } else {
     text_nodes->Append(CreateTextNode(text_utf8));
   }
 
   node->Set(kTextBoxNodes, text_nodes);  // Takes ownership of |text_nodes|.
   return node;
 }
 
 base::Value* PDFiumPage::CreateTextNode(const std::string& text) {
@@ skipping 76 matching lines @@
   return static_cast<base::char16>(FPDFText_GetUnicode(GetTextPage(), index));
 }
 
 int PDFiumPage::GetCharCount() {
   if (!available_)
     return 0;
   return FPDFText_CountChars(GetTextPage());
 }
 
 PDFiumPage::Area PDFiumPage::GetLinkTarget(
-    FPDF_LINK link, PDFiumPage::LinkTarget* target) {
+    FPDF_LINK link, PDFiumPage::LinkTarget* target) const {
   FPDF_DEST dest = FPDFLink_GetDest(engine_->doc(), link);
-  if (dest != NULL)
+  if (dest)
     return GetDestinationTarget(dest, target);
 
   FPDF_ACTION action = FPDFLink_GetAction(link);
   if (action) {
     switch (FPDFAction_GetType(action)) {
       case PDFACTION_GOTO: {
           FPDF_DEST dest = FPDFAction_GetDest(engine_->doc(), action);
           if (dest)
             return GetDestinationTarget(dest, target);
           // TODO(gene): We don't fully support all types of the in-document
@@ skipping 17 matching lines @@
         } break;
       // TODO(gene): We don't support PDFACTION_REMOTEGOTO and PDFACTION_LAUNCH
       // at the moment.
     }
   }
 
   return NONSELECTABLE_AREA;
 }
 
 PDFiumPage::Area PDFiumPage::GetDestinationTarget(
-    FPDF_DEST destination, PDFiumPage::LinkTarget* target) {
-  int page_index = FPDFDest_GetPageIndex(engine_->doc(), destination);
-  if (target) {
-    target->page = page_index;
-  }
+    FPDF_DEST destination, PDFiumPage::LinkTarget* target) const {
+  if (target)
+    target->page = FPDFDest_GetPageIndex(engine_->doc(), destination);
   return DOCLINK_AREA;
 }
 
 int PDFiumPage::GetLink(int char_index, PDFiumPage::LinkTarget* target) {
   if (!available_)
     return -1;
 
   CalculateLinks();
 
   // Get the bounding box of the rect again, since it might have moved because
   // of the tolerance above.
   double left, right, bottom, top;
   FPDFText_GetCharBox(GetTextPage(), char_index, &left, &right, &bottom, &top);
 
   pp::Point origin(
       PageToScreen(pp::Point(), 1.0, left, top, right, bottom, 0).point());
   for (size_t i = 0; i < links_.size(); ++i) {
-    for (size_t j = 0; j < links_[i].rects.size(); ++j) {
-      if (links_[i].rects[j].Contains(origin)) {
+    for (const auto& rect : links_[i].rects) {
+      if (rect.Contains(origin)) {
         if (target)
           target->url = links_[i].url;
         return i;
       }
     }
   }
   return -1;
 }
 
 std::vector<int> PDFiumPage::GetLinks(pp::Rect text_area,
                                       std::vector<LinkTarget>* targets) {
+  std::vector<int> links;
   if (!available_)
-    return std::vector<int>();
+    return links;
 
   CalculateLinks();
 
-  std::vector<int> links;
-
   for (size_t i = 0; i < links_.size(); ++i) {
-    for (size_t j = 0; j < links_[i].rects.size(); ++j) {
-      if (links_[i].rects[j].Intersects(text_area)) {
+    for (const auto& rect : links_[i].rects) {
+      if (rect.Intersects(text_area)) {
         if (targets) {
           LinkTarget target;
           target.url = links_[i].url;
           targets->push_back(target);
         }
         links.push_back(i);
       }
     }
   }
   return links;
@@ skipping 54 matching lines @@
   }
   FPDFLink_CloseWebLinks(links);
 }
 
 pp::Rect PDFiumPage::PageToScreen(const pp::Point& offset,
                                   double zoom,
                                   double left,
                                   double top,
                                   double right,
                                   double bottom,
-                                  int rotation) {
+                                  int rotation) const {
   if (!available_)
     return pp::Rect();
 
   int new_left, new_top, new_right, new_bottom;
   FPDF_PageToDevice(
       page_,
       static_cast<int>((rect_.x() - offset.x()) * zoom),
       static_cast<int>((rect_.y() - offset.y()) * zoom),
       static_cast<int>(ceil(rect_.width() * zoom)),
       static_cast<int>(ceil(rect_.height() * zoom)),
@@ skipping 27 matching lines @@
   page_->loading_count_--;
 }
 
 PDFiumPage::Link::Link() {
 }
 
 PDFiumPage::Link::~Link() {
 }
 
 }  // namespace chrome_pdf