Mark methods with override in 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 "base/i18n/icu_encoding_detection.h"
 #include "base/i18n/icu_string_conversions.h"
 #include "base/json/json_writer.h"
+#include "base/lazy_instance.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/memory/scoped_ptr.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 "base/values.h"
@@ skipping 3746 matching lines @@
 
 ScopedUnsupportedFeature::ScopedUnsupportedFeature(PDFiumEngine* engine)
     : engine_(engine), old_engine_(g_engine_for_unsupported) {
   g_engine_for_unsupported = engine_;
 }
 
 ScopedUnsupportedFeature::~ScopedUnsupportedFeature() {
   g_engine_for_unsupported = old_engine_;
 }
 
-PDFEngineExports* PDFEngineExports::Create() {
-  return new PDFiumEngineExports;
-}
-
 namespace {
 
+base::LazyInstance<PDFiumEngineExports>::Leaky g_pdf_engine_exports =
+    LAZY_INSTANCE_INITIALIZER;
+
 int CalculatePosition(FPDF_PAGE page,
                       const PDFiumEngineExports::RenderingSettings& settings,
                       pp::Rect* dest) {
   int page_width = static_cast<int>(ConvertUnitDouble(FPDF_GetPageWidth(page),
                                                       kPointsPerInch,
                                                       settings.dpi_x));
   int page_height = static_cast<int>(ConvertUnitDouble(FPDF_GetPageHeight(page),
                                                        kPointsPerInch,
                                                        settings.dpi_y));
 
@@ skipping 45 matching lines @@
   if (settings.center_in_bounds) {
     pp::Point offset((settings.bounds.width() - dest->width()) / 2,
                      (settings.bounds.height() - dest->height()) / 2);
     dest->Offset(offset);
   }
   return rotate;
 }
 
 }  // namespace
 
+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);
   if (!doc)
     return false;
   FPDF_PAGE page = FPDF_LoadPage(doc, page_number);
@@ skipping 63 matching lines @@
     FPDFBitmap_Destroy(bitmap);
   } else {
     FPDF_RenderPage(dc, page, dest.x(), dest.y(), dest.width(), dest.height(),
                     rotate, FPDF_ANNOT | FPDF_PRINTING | FPDF_NO_CATCH);
   }
   RestoreDC(dc, save_state);
   FPDF_ClosePage(page);
   FPDF_CloseDocument(doc);
   return true;
 }
-#endif  // OS_WIN
+#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);
   if (!doc)
     return false;
@@ skipping 58 matching lines @@
     double* height) {
   FPDF_DOCUMENT doc = FPDF_LoadMemDocument(pdf_buffer, pdf_buffer_size, NULL);
   if (!doc)
     return false;
   bool success = FPDF_GetPageSizeByIndex(doc, page_number, width, height) != 0;
   FPDF_CloseDocument(doc);
   return success;
 }
 
 }  // namespace chrome_pdf