Turn on enforce-in-pdf Clang plugin flag.

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 <algorithm>
@@ skipping 64 matching lines @@
 
 }  // namespace
 
 namespace chrome_pdf {
 
 PDFiumPage::PDFiumPage(PDFiumEngine* engine,
                        int i,
                        const pp::Rect& r,
                        bool available)
     : engine_(engine),
-      page_(NULL),
-      text_page_(NULL),
+      page_(nullptr),
+      text_page_(nullptr),
       index_(i),
       loading_count_(0),
       rect_(r),
       calculated_links_(false),
-      available_(available) {
-}
+      available_(available) {}
+
+PDFiumPage::PDFiumPage(const PDFiumPage& that) = default;
 
 PDFiumPage::~PDFiumPage() {
   DCHECK_EQ(0, loading_count_);
 }
 
 void PDFiumPage::Unload() {
   // Do not unload while in the middle of a load.
   if (loading_count_)
     return;
 
   if (text_page_) {
     FPDFText_ClosePage(text_page_);
-    text_page_ = NULL;
+    text_page_ = nullptr;
   }
 
   if (page_) {
     if (engine_->form()) {
       FORM_OnBeforeClosePage(page_, engine_->form());
     }
     FPDF_ClosePage(page_);
-    page_ = NULL;
+    page_ = nullptr;
   }
 }
 
 FPDF_PAGE PDFiumPage::GetPage() {
   ScopedUnsupportedFeature scoped_unsupported_feature(engine_);
   if (!available_)
-    return NULL;
+    return nullptr;
   if (!page_) {
     ScopedLoadCounter scoped_load(this);
     page_ = FPDF_LoadPage(engine_->doc(), index_);
     if (page_ && engine_->form()) {
       FORM_OnAfterLoadPage(page_, engine_->form());
     }
   }
   return page_;
 }
 
 FPDF_PAGE PDFiumPage::GetPrintPage() {
   ScopedUnsupportedFeature scoped_unsupported_feature(engine_);
   if (!available_)
-    return NULL;
+    return nullptr;
   if (!page_) {
     ScopedLoadCounter scoped_load(this);
     page_ = FPDF_LoadPage(engine_->doc(), index_);
   }
   return page_;
 }
 
 void PDFiumPage::ClosePrintPage() {
   // Do not close |page_| while in the middle of a load.
   if (loading_count_)
     return;
 
   if (page_) {
     FPDF_ClosePage(page_);
-    page_ = NULL;
+    page_ = nullptr;
   }
 }
 
 FPDF_TEXTPAGE PDFiumPage::GetTextPage() {
   if (!available_)
-    return NULL;
+    return nullptr;
   if (!text_page_) {
     ScopedLoadCounter scoped_load(this);
     text_page_ = FPDFText_LoadPage(GetPage());
   }
   return text_page_;
 }
 
 void PDFiumPage::GetTextRunInfo(int start_char_index,
                                 uint32_t* out_len,
                                 double* out_font_size,
@@ skipping 146 matching lines @@
           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
           // links. Need to implement that. There is a bug to track that:
           // http://code.google.com/p/chromium/issues/detail?id=55776
         } break;
       case PDFACTION_URI: {
           if (target) {
             size_t buffer_size =
-                FPDFAction_GetURIPath(engine_->doc(), action, NULL, 0);
+                FPDFAction_GetURIPath(engine_->doc(), action, nullptr, 0);
             if (buffer_size > 0) {
               PDFiumAPIStringBufferAdapter<std::string> api_string_adapter(
                   &target->url, buffer_size, true);
               void* data = api_string_adapter.GetData();
               size_t bytes_written = FPDFAction_GetURIPath(
                   engine_->doc(), action, data, buffer_size);
               api_string_adapter.Close(bytes_written);
             }
           }
           return WEBLINK_AREA;
@@ skipping 63 matching lines @@
 
 void PDFiumPage::CalculateLinks() {
   if (calculated_links_)
     return;
 
   calculated_links_ = true;
   FPDF_PAGELINK links = FPDFLink_LoadWebLinks(GetTextPage());
   int count = FPDFLink_CountWebLinks(links);
   for (int i = 0; i < count; ++i) {
     base::string16 url;
-    int url_length = FPDFLink_GetURL(links, i, NULL, 0);
+    int url_length = FPDFLink_GetURL(links, i, nullptr, 0);
     if (url_length > 0) {
       PDFiumAPIStringBufferAdapter<base::string16> api_string_adapter(
           &url, url_length, true);
       unsigned short* data =
           reinterpret_cast<unsigned short*>(api_string_adapter.GetData());
       int actual_length = FPDFLink_GetURL(links, i, data, url_length);
       api_string_adapter.Close(actual_length);
     }
     Link link;
     link.url = base::UTF16ToUTF8(url);
@@ skipping 73 matching lines @@
 
 PDFiumPage::ScopedLoadCounter::ScopedLoadCounter(PDFiumPage* page)
     : page_(page) {
   page_->loading_count_++;
 }
 
 PDFiumPage::ScopedLoadCounter::~ScopedLoadCounter() {
   page_->loading_count_--;
 }
 
-PDFiumPage::Link::Link() {
-}
+PDFiumPage::Link::Link() = default;
 
-PDFiumPage::Link::~Link() {
-}
+PDFiumPage::Link::Link(const Link& that) = default;
+
+PDFiumPage::Link::~Link() = default;
 
 }  // namespace chrome_pdf