Cleanup misc nits in the PDF plugin.

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 138 matching lines @@
     FPDF_AddInstalledFont(mapper, font_map->fontname, font_map->charset);
   }
 }
 
 void* MapFont(struct _FPDF_SYSFONTINFO*, int weight, int italic,
               int charset, int pitch_family, const char* face, int* exact) {
   // Do not attempt to map fonts if pepper is not initialized (for privet local
   // printing).
   // TODO(noamsml): Real font substitution (http://crbug.com/391978)
   if (!pp::Module::Get())
-    return NULL;
+    return nullptr;
 
   pp::BrowserFontDescription description;
 
   // Pretend the system does not have the Symbol font to force a fallback to
   // the built in Symbol font in CFX_FontMapper::FindSubstFont().
   if (strcmp(face, "Symbol") == 0)
-    return NULL;
+    return nullptr;
 
   if (pitch_family & FXFONT_FF_FIXEDPITCH) {
     description.set_family(PP_BROWSERFONT_TRUSTED_FAMILY_MONOSPACE);
   } else if (pitch_family & FXFONT_FF_ROMAN) {
     description.set_family(PP_BROWSERFONT_TRUSTED_FAMILY_SERIF);
   }
 
   static const struct {
     const char* pdf_name;
     const char* face;
@@ skipping 70 matching lines @@
     if (face_utf8.empty())
       return nullptr;
 
     description.set_face(face_utf8);
     description.set_weight(WeightToBrowserFontTrustedWeight(weight));
     description.set_italic(italic > 0);
   }
 
   if (!pp::PDF::IsAvailable()) {
     NOTREACHED();
-    return NULL;
+    return nullptr;
   }
 
   PP_Resource font_resource = pp::PDF::GetFontFileWithFallback(
       pp::InstanceHandle(g_last_instance_id),
       &description.pp_font_description(),
       static_cast<PP_PrivateFontCharset>(charset));
   long res_id = font_resource;
   return reinterpret_cast<void*>(res_id);
 }
 
@@ skipping 131 matching lines @@
   base::ReplaceChars(*text, kCr, kBlank, text);
 #elif defined(OS_WIN)
   // Do nothing
 #else
   NOTIMPLEMENTED();
 #endif
 }
 
 // Returns a VarDictionary (representing a bookmark), which in turn contains
 // child VarDictionaries (representing the child bookmarks).
-// If NULL is passed in as the bookmark then we traverse from the "root".
+// If nullptr is passed in as the bookmark then we traverse from the "root".
 // Note that the "root" bookmark contains no useful information.
 pp::VarDictionary TraverseBookmarks(FPDF_DOCUMENT doc,
                                     FPDF_BOOKMARK bookmark,
                                     unsigned int depth) {
   pp::VarDictionary dict;
   base::string16 title;
   unsigned long buffer_size = FPDFBookmark_GetTitle(bookmark, nullptr, 0);
   if (buffer_size > 0) {
     PDFiumAPIStringBufferSizeInBytesAdapter<base::string16> api_string_adapter(
         &title, buffer_size, true);
@@ skipping 105 matching lines @@
 PDFEngine* PDFEngine::Create(PDFEngine::Client* client) {
   return new PDFiumEngine(client);
 }
 
 PDFiumEngine::PDFiumEngine(PDFEngine::Client* client)
     : client_(client),
       current_zoom_(1.0),
       current_rotation_(0),
       doc_loader_(this),
       password_tries_remaining_(0),
-      doc_(NULL),
-      form_(NULL),
+      doc_(nullptr),
+      form_(nullptr),
       defer_page_unload_(false),
       selecting_(false),
       mouse_down_state_(PDFiumPage::NONSELECTABLE_AREA,
                         PDFiumPage::LinkTarget()),
       next_page_to_search_(-1),
       last_page_to_search_(-1),
       last_character_index_to_search_(-1),
       permissions_(0),
       permissions_handler_revision_(-1),
-      fpdf_availability_(NULL),
+      fpdf_availability_(nullptr),
       next_timer_id_(0),
       last_page_mouse_down_(-1),
       most_visible_page_(-1),
       called_do_document_action_(false),
       render_grayscale_(false),
       progressive_paint_timeout_(0),
       getting_password_(false) {
   find_factory_.Initialize(this);
   password_factory_.Initialize(this);
 
   file_access_.m_FileLen = 0;
   file_access_.m_GetBlock = &GetBlock;
   file_access_.m_Param = &doc_loader_;
 
   file_availability_.version = 1;
   file_availability_.IsDataAvail = &IsDataAvail;
   file_availability_.loader = &doc_loader_;
 
   download_hints_.version = 1;
   download_hints_.AddSegment = &AddSegment;
   download_hints_.loader = &doc_loader_;
 
   // Initialize FPDF_FORMFILLINFO member variables.  Deriving from this struct
   // allows the static callbacks to be able to cast the FPDF_FORMFILLINFO in
   // callbacks to ourself instead of maintaining a map of them to
   // PDFiumEngine.
   FPDF_FORMFILLINFO::version = 1;
   FPDF_FORMFILLINFO::m_pJsPlatform = this;
-  FPDF_FORMFILLINFO::Release = NULL;
+  FPDF_FORMFILLINFO::Release = nullptr;
   FPDF_FORMFILLINFO::FFI_Invalidate = Form_Invalidate;
   FPDF_FORMFILLINFO::FFI_OutputSelectedRect = Form_OutputSelectedRect;
   FPDF_FORMFILLINFO::FFI_SetCursor = Form_SetCursor;
   FPDF_FORMFILLINFO::FFI_SetTimer = Form_SetTimer;
   FPDF_FORMFILLINFO::FFI_KillTimer = Form_KillTimer;
   FPDF_FORMFILLINFO::FFI_GetLocalTime = Form_GetLocalTime;
   FPDF_FORMFILLINFO::FFI_OnChange = Form_OnChange;
   FPDF_FORMFILLINFO::FFI_GetPage = Form_GetPage;
   FPDF_FORMFILLINFO::FFI_GetCurrentPage = Form_GetCurrentPage;
   FPDF_FORMFILLINFO::FFI_GetRotation = Form_GetRotation;
@@ skipping 23 matching lines @@
   IPDF_JSPLATFORM::app_beep = Form_Beep;
   IPDF_JSPLATFORM::app_response = Form_Response;
   IPDF_JSPLATFORM::Doc_getFilePath = Form_GetFilePath;
   IPDF_JSPLATFORM::Doc_mail = Form_Mail;
   IPDF_JSPLATFORM::Doc_print = Form_Print;
   IPDF_JSPLATFORM::Doc_submitForm = Form_SubmitForm;
   IPDF_JSPLATFORM::Doc_gotoPage = Form_GotoPage;
   IPDF_JSPLATFORM::Field_browse = Form_Browse;
 
   IFSDK_PAUSE::version = 1;
-  IFSDK_PAUSE::user = NULL;
+  IFSDK_PAUSE::user = nullptr;
   IFSDK_PAUSE::NeedToPauseNow = Pause_NeedToPauseNow;
 
 #if defined(OS_LINUX)
   // PreviewModeClient does not know its pp::Instance.
   pp::Instance* instance = client_->GetPluginInstance();
   if (instance)
     g_last_instance_id = instance->pp_instance();
 #endif
 }
 
@@ skipping 714 matching lines @@
                                                        print_settings,
                                                        &pages_to_print[i]);
 
     if (!temp_doc)
       break;
 
     pp::Buffer_Dev buffer = GetFlattenedPrintData(temp_doc);
     FPDF_CloseDocument(temp_doc);
 
     PDFiumMemBufferFileRead file_read(buffer.data(), buffer.size());
-    temp_doc = FPDF_LoadCustomDocument(&file_read, NULL);
+    temp_doc = FPDF_LoadCustomDocument(&file_read, nullptr);
 
     FPDF_BOOL imported = FPDF_ImportPages(output_doc, temp_doc, "1", i);
     FPDF_CloseDocument(temp_doc);
     if (!imported)
       break;
   }
 
   pp::Buffer_Dev buffer;
   if (i == pages_to_print.size()) {
     FPDF_CopyViewerPreferences(output_doc, doc_);
@@ skipping 864 matching lines @@
     if (page->available())
       selection_.push_back(PDFiumRange(page, 0, page->GetCharCount()));
   }
 }
 
 int PDFiumEngine::GetNumberOfPages() {
   return pages_.size();
 }
 
 pp::VarArray PDFiumEngine::GetBookmarks() {
-  pp::VarDictionary dict = TraverseBookmarks(doc_, NULL, 0);
+  pp::VarDictionary dict = TraverseBookmarks(doc_, nullptr, 0);
   // The root bookmark contains no useful information.
   return pp::VarArray(dict.Get(pp::Var("children")));
 }
 
 int PDFiumEngine::GetNamedDestinationPage(const std::string& destination) {
   // Look for the destination.
   FPDF_DEST dest = FPDF_GetNamedDestByName(doc_, destination.c_str());
   if (!dest) {
     // Look for a bookmark with the same name.
     base::string16 destination_wide = base::UTF8ToUTF16(destination);
@@ skipping 369 matching lines @@
 }
 
 bool PDFiumEngine::IsPageVisible(int index) const {
   return ContainsValue(visible_pages_, index);
 }
 
 bool PDFiumEngine::CheckPageAvailable(int index, std::vector<int>* pending) {
   if (!doc_ || !form_)
     return false;
 
-  if (static_cast<int>(pages_.size()) > index && pages_[index]->available())
+  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_)) {
     size_t j;
     for (j = 0; j < pending->size(); ++j) {
       if ((*pending)[j] == index)
         break;
     }
 
     if (j == pending->size())
       pending->push_back(index);
     return false;
   }
 
-  if (static_cast<int>(pages_.size()) > index)
+  if (index < num_pages)
     pages_[index]->set_available(true);
   if (!default_page_size_.GetArea())
     default_page_size_ = GetPageSize(index);
   return true;
 }
 
 pp::Size PDFiumEngine::GetPageSize(int index) {
   pp::Size size;
   double width_in_points = 0;
   double height_in_points = 0;
@@ skipping 12 matching lines @@
   return size;
 }
 
 int PDFiumEngine::StartPaint(int page_index, const pp::Rect& dirty) {
   // For the first time we hit paint, do nothing and just record the paint for
   // the next callback.  This keeps the UI responsive in case the user is doing
   // a lot of scrolling.
   ProgressivePaint progressive;
   progressive.rect = dirty;
   progressive.page_index = page_index;
-  progressive.bitmap = NULL;
+  progressive.bitmap = nullptr;
   progressive.painted_ = false;
   progressive_paints_.push_back(progressive);
   return progressive_paints_.size() - 1;
 }
 
 bool PDFiumEngine::ContinuePaint(int progressive_index,
                                  pp::ImageData* image_data) {
   DCHECK_GE(progressive_index, 0);
   DCHECK_LT(static_cast<size_t>(progressive_index), progressive_paints_.size());
   DCHECK(image_data);
@@ skipping 145 matching lines @@
 
 void PDFiumEngine::DrawSelections(int progressive_index,
                                   pp::ImageData* image_data) {
   DCHECK_GE(progressive_index, 0);
   DCHECK_LT(static_cast<size_t>(progressive_index), progressive_paints_.size());
   DCHECK(image_data);
 
   int page_index = progressive_paints_[progressive_index].page_index;
   pp::Rect dirty_in_screen = progressive_paints_[progressive_index].rect;
 
-  void* region = NULL;
+  void* region = nullptr;
   int stride;
   GetRegion(dirty_in_screen.point(), image_data, &region, &stride);
 
   std::vector<pp::Rect> highlighted_rects;
   pp::Rect visible_rect = GetVisibleRect();
   for (auto& range : selection_) {
     if (range.page_index() != page_index)
       continue;
 
     std::vector<pp::Rect> rects = range.GetScreenRects(
@@ skipping 44 matching lines @@
   }
   return -1;
 }
 
 FPDF_BITMAP PDFiumEngine::CreateBitmap(const pp::Rect& rect,
                                        pp::ImageData* image_data) const {
   void* region;
   int stride;
   GetRegion(rect.point(), image_data, &region, &stride);
   if (!region)
-    return NULL;
+    return nullptr;
   return FPDFBitmap_CreateEx(
       rect.width(), rect.height(), FPDFBitmap_BGRx, region, stride);
 }
 
 void PDFiumEngine::GetPDFiumRect(
     int page_index, const pp::Rect& rect, int* start_x, int* start_y,
     int* size_x, int* size_y) const {
   pp::Rect page_rect = GetScreenRect(pages_[page_index]->rect());
   page_rect.Offset(-rect.x(), -rect.y());
 
@@ skipping 358 matching lines @@
   DrawShadow(image_data, shadow_rect, page_rect, clip_rect, *page_shadow_);
 }
 
 void PDFiumEngine::GetRegion(const pp::Point& location,
                              pp::ImageData* image_data,
                              void** region,
                              int* stride) const {
   if (image_data->is_null()) {
     DCHECK(plugin_size_.IsEmpty());
     *stride = 0;
-    *region = NULL;
+    *region = nullptr;
     return;
   }
   char* buffer = static_cast<char*>(image_data->data());
   *stride = image_data->stride();
 
   pp::Point offset_location = location + page_offset_;
   // TODO: update this when we support BIDI and scrollbars can be on the left.
   if (!buffer ||
       !pp::Rect(page_offset_, plugin_size_).Contains(offset_location)) {
-    *region = NULL;
+    *region = nullptr;
     return;
   }
 
   buffer += location.y() * (*stride);
   buffer += (location.x() + page_offset_.x()) * 4;
   *region = buffer;
 }
 
 void PDFiumEngine::OnSelectionChanged() {
   pp::PDF::SetSelectedText(GetPluginInstance(), GetSelectedText().c_str());
@@ skipping 101 matching lines @@
 
 void PDFiumEngine::Form_OnChange(FPDF_FORMFILLINFO* param) {
   // Don't care about.
 }
 
 FPDF_PAGE PDFiumEngine::Form_GetPage(FPDF_FORMFILLINFO* param,
                                      FPDF_DOCUMENT document,
                                      int page_index) {
   PDFiumEngine* engine = static_cast<PDFiumEngine*>(param);
   if (page_index < 0 || page_index >= static_cast<int>(engine->pages_.size()))
-    return NULL;
+    return nullptr;
   return engine->pages_[page_index]->GetPage();
 }
 
 FPDF_PAGE PDFiumEngine::Form_GetCurrentPage(FPDF_FORMFILLINFO* param,
                                             FPDF_DOCUMENT document) {
   // TODO(jam): find out what this is used for.
   PDFiumEngine* engine = static_cast<PDFiumEngine*>(param);
   int index = engine->last_page_mouse_down_;
   if (index == -1) {
     index = engine->GetMostVisiblePage();
     if (index == -1) {
       NOTREACHED();
-      return NULL;
+      return nullptr;
     }
   }
 
   return engine->pages_[index]->GetPage();
 }
 
 int PDFiumEngine::Form_GetRotation(FPDF_FORMFILLINFO* param, FPDF_PAGE page) {
   return 0;
 }
 
@@ skipping 283 matching lines @@
 PDFEngineExports* PDFEngineExports::Get() {
   return g_pdf_engine_exports.Pointer();
 }
 
 #if defined(OS_WIN)
 bool PDFiumEngineExports::RenderPDFPageToDC(const void* pdf_buffer,
                                             int buffer_size,
                                             int page_number,
                                             const RenderingSettings& settings,
                                             HDC dc) {
-  FPDF_DOCUMENT doc = FPDF_LoadMemDocument(pdf_buffer, buffer_size, NULL);
+  FPDF_DOCUMENT doc = FPDF_LoadMemDocument(pdf_buffer, buffer_size, nullptr);
   if (!doc)
     return false;
   FPDF_PAGE page = FPDF_LoadPage(doc, page_number);
   if (!page) {
     FPDF_CloseDocument(doc);
     return false;
   }
   RenderingSettings new_settings = settings;
   // calculate the page size
   if (new_settings.dpi_x == -1)
@@ skipping 51 matching lines @@
   return true;
 }
 #endif  // defined(OS_WIN)
 
 bool PDFiumEngineExports::RenderPDFPageToBitmap(
     const void* pdf_buffer,
     int pdf_buffer_size,
     int page_number,
     const RenderingSettings& settings,
     void* bitmap_buffer) {
-  FPDF_DOCUMENT doc = FPDF_LoadMemDocument(pdf_buffer, pdf_buffer_size, NULL);
+  FPDF_DOCUMENT doc =
+      FPDF_LoadMemDocument(pdf_buffer, pdf_buffer_size, nullptr);
   if (!doc)
     return false;
   FPDF_PAGE page = FPDF_LoadPage(doc, page_number);
   if (!page) {
     FPDF_CloseDocument(doc);
     return false;
   }
 
   pp::Rect dest;
   int rotate = CalculatePosition(page, settings, &dest);
@@ skipping 13 matching lines @@
   FPDFBitmap_Destroy(bitmap);
   FPDF_ClosePage(page);
   FPDF_CloseDocument(doc);
   return true;
 }
 
 bool PDFiumEngineExports::GetPDFDocInfo(const void* pdf_buffer,
                                         int buffer_size,
                                         int* page_count,
                                         double* max_page_width) {
-  FPDF_DOCUMENT doc = FPDF_LoadMemDocument(pdf_buffer, buffer_size, NULL);
+  FPDF_DOCUMENT doc = FPDF_LoadMemDocument(pdf_buffer, buffer_size, nullptr);
   if (!doc)
     return false;
   int page_count_local = FPDF_GetPageCount(doc);
   if (page_count) {
     *page_count = page_count_local;
   }
   if (max_page_width) {
     *max_page_width = 0;
     for (int page_number = 0; page_number < page_count_local; page_number++) {
       double page_width = 0;
       double page_height = 0;
       FPDF_GetPageSizeByIndex(doc, page_number, &page_width, &page_height);
       if (page_width > *max_page_width) {
         *max_page_width = page_width;
       }
     }
   }
   FPDF_CloseDocument(doc);
   return true;
 }
 
 bool PDFiumEngineExports::GetPDFPageSizeByIndex(
     const void* pdf_buffer,
     int pdf_buffer_size,
     int page_number,
     double* width,
     double* height) {
-  FPDF_DOCUMENT doc = FPDF_LoadMemDocument(pdf_buffer, pdf_buffer_size, NULL);
+  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