Add ptr_util.h from base until std::make_unique<> available

fpdfsdk/fpdfview.cpp

 // Copyright 2014 PDFium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 // Original code copyright 2014 Foxit Software Inc. http://www.foxitsoftware.com
 
 #include "public/fpdfview.h"
 
 #include <memory>
 #include <utility>
@@ skipping 15 matching lines @@
 #include "core/fxcrt/fx_safe_types.h"
 #include "core/fxge/cfx_fxgedevice.h"
 #include "core/fxge/cfx_gemodule.h"
 #include "fpdfsdk/cpdfsdk_pageview.h"
 #include "fpdfsdk/fsdk_define.h"
 #include "fpdfsdk/fsdk_pauseadapter.h"
 #include "fpdfsdk/javascript/ijs_runtime.h"
 #include "public/fpdf_ext.h"
 #include "public/fpdf_progressive.h"
 #include "third_party/base/numerics/safe_conversions_impl.h"
+#include "third_party/base/ptr_util.h"
 
 #ifdef PDF_ENABLE_XFA
 #include "fpdfsdk/fpdfxfa/fpdfxfa_app.h"
 #include "fpdfsdk/fpdfxfa/fpdfxfa_doc.h"
 #include "fpdfsdk/fpdfxfa/fpdfxfa_page.h"
 #include "fpdfsdk/fpdfxfa/fpdfxfa_util.h"
 #include "public/fpdf_formfill.h"
 #endif  // PDF_ENABLE_XFA
 
 #if _FXM_PLATFORM_ == _FXM_PLATFORM_WINDOWS_
@@ skipping 16 matching lines @@
 #ifdef PDF_ENABLE_XFA
   return doc ? UnderlyingFromFPDFDocument(doc)->GetPDFDoc() : nullptr;
 #else   // PDF_ENABLE_XFA
   return UnderlyingFromFPDFDocument(doc);
 #endif  // PDF_ENABLE_XFA
 }
 
 FPDF_DOCUMENT FPDFDocumentFromCPDFDocument(CPDF_Document* doc) {
 #ifdef PDF_ENABLE_XFA
   return doc ? FPDFDocumentFromUnderlying(new CPDFXFA_Document(
-                   WrapUnique(doc), CPDFXFA_App::GetInstance()))
+                   pdfium::WrapUnique(doc), CPDFXFA_App::GetInstance()))
              : nullptr;
 #else   // PDF_ENABLE_XFA
   return FPDFDocumentFromUnderlying(doc);
 #endif  // PDF_ENABLE_XFA
 }
 
 CPDF_Page* CPDFPageFromFPDFPage(FPDF_PAGE page) {
 #ifdef PDF_ENABLE_XFA
   return page ? UnderlyingFromFPDFPage(page)->GetPDFPage() : nullptr;
 #else   // PDF_ENABLE_XFA
@@ skipping 484 matching lines @@
                                        int start_y,
                                        int size_x,
                                        int size_y,
                                        int rotate,
                                        int flags) {
   CPDF_Page* pPage = CPDFPageFromFPDFPage(page);
   if (!pPage)
     return;
 
   CPDF_PageRenderContext* pContext = new CPDF_PageRenderContext;
-  pPage->SetRenderContext(WrapUnique(pContext));
+  pPage->SetRenderContext(pdfium::WrapUnique(pContext));
 
   std::unique_ptr<CFX_DIBitmap> pBitmap;
   const bool bNewBitmap =
       pPage->BackgroundAlphaNeeded() || pPage->HasImageMask();
   if (bNewBitmap) {
-    pBitmap = WrapUnique(new CFX_DIBitmap);
+    pBitmap = pdfium::MakeUnique<CFX_DIBitmap>();
     pBitmap->Create(size_x, size_y, FXDIB_Argb);
     pBitmap->Clear(0x00ffffff);
     CFX_FxgeDevice* pDevice = new CFX_FxgeDevice;
-    pContext->m_pDevice = WrapUnique(pDevice);
+    pContext->m_pDevice = pdfium::WrapUnique(pDevice);
     pDevice->Attach(pBitmap.get(), false, nullptr, false);
   } else {
-    pContext->m_pDevice = WrapUnique(new CFX_WindowsDevice(dc));
+    pContext->m_pDevice = pdfium::MakeUnique<CFX_WindowsDevice>(dc);
   }
 
   FPDF_RenderPage_Retail(pContext, page, start_x, start_y, size_x, size_y,
                          rotate, flags, TRUE, nullptr);
 
   if (bNewBitmap) {
     CFX_WindowsDevice WinDC(dc);
     if (WinDC.GetDeviceCaps(FXDC_DEVICE_CLASS) == FXDC_PRINTER) {
-      std::unique_ptr<CFX_DIBitmap> pDst = WrapUnique(new CFX_DIBitmap);
+      std::unique_ptr<CFX_DIBitmap> pDst = pdfium::MakeUnique<CFX_DIBitmap>();
       int pitch = pBitmap->GetPitch();
       pDst->Create(size_x, size_y, FXDIB_Rgb32);
       FXSYS_memset(pDst->GetBuffer(), -1, pitch * size_y);
       pDst->CompositeBitmap(0, 0, size_x, size_y, pBitmap.get(), 0, 0,
                             FXDIB_BLEND_NORMAL, nullptr, FALSE, nullptr);
       WinDC.StretchDIBits(pDst.get(), 0, 0, size_x, size_y);
     } else {
       WinDC.SetDIBits(pBitmap.get(), 0, 0);
     }
   }
@@ skipping 11 matching lines @@
                                              int rotate,
                                              int flags) {
   if (!bitmap)
     return;
 
   CPDF_Page* pPage = CPDFPageFromFPDFPage(page);
   if (!pPage)
     return;
 
   CPDF_PageRenderContext* pContext = new CPDF_PageRenderContext;
-  pPage->SetRenderContext(WrapUnique(pContext));
+  pPage->SetRenderContext(pdfium::WrapUnique(pContext));
   CFX_FxgeDevice* pDevice = new CFX_FxgeDevice;
   pContext->m_pDevice.reset(pDevice);
   CFX_DIBitmap* pBitmap = CFXBitmapFromFPDFBitmap(bitmap);
   pDevice->Attach(pBitmap, !!(flags & FPDF_REVERSE_BYTE_ORDER), nullptr, false);
 
   FPDF_RenderPage_Retail(pContext, page, start_x, start_y, size_x, size_y,
                          rotate, flags, TRUE, nullptr);
 
   pPage->SetRenderContext(std::unique_ptr<CPDF_PageRenderContext>());
 }
 
 #ifdef _SKIA_SUPPORT_
 DLLEXPORT FPDF_RECORDER STDCALL FPDF_RenderPageSkp(FPDF_PAGE page,
                                                    int size_x,
                                                    int size_y) {
   CPDF_Page* pPage = CPDFPageFromFPDFPage(page);
   if (!pPage)
     return nullptr;
 
   CPDF_PageRenderContext* pContext = new CPDF_PageRenderContext;
-  pPage->SetRenderContext(WrapUnique(pContext));
+  pPage->SetRenderContext(pdfium::WrapUnique(pContext));
   CFX_FxgeDevice* skDevice = new CFX_FxgeDevice;
   FPDF_RECORDER recorder = skDevice->CreateRecorder(size_x, size_y);
   pContext->m_pDevice.reset(skDevice);
   FPDF_RenderPage_Retail(pContext, page, 0, 0, size_x, size_y, 0, 0, TRUE,
                          nullptr);
   pPage->SetRenderContext(std::unique_ptr<CPDF_PageRenderContext>());
   return recorder;
 }
 #endif
 
@@ skipping 176 matching lines @@
                             int size_y,
                             int rotate,
                             int flags,
                             FX_BOOL bNeedToRestore,
                             IFSDK_PAUSE_Adapter* pause) {
   CPDF_Page* pPage = CPDFPageFromFPDFPage(page);
   if (!pPage)
     return;
 
   if (!pContext->m_pOptions)
-    pContext->m_pOptions = WrapUnique(new CPDF_RenderOptions);
+    pContext->m_pOptions = pdfium::MakeUnique<CPDF_RenderOptions>();
 
   if (flags & FPDF_LCD_TEXT)
     pContext->m_pOptions->m_Flags |= RENDER_CLEARTYPE;
   else
     pContext->m_pOptions->m_Flags &= ~RENDER_CLEARTYPE;
   if (flags & FPDF_NO_NATIVETEXT)
     pContext->m_pOptions->m_Flags |= RENDER_NO_NATIVETEXT;
   if (flags & FPDF_RENDER_LIMITEDIMAGECACHE)
     pContext->m_pOptions->m_Flags |= RENDER_LIMITEDIMAGECACHE;
   if (flags & FPDF_RENDER_FORCEHALFTONE)
@@ skipping 18 matching lines @@
   pContext->m_pOptions->m_pOCContext =
       new CPDF_OCContext(pPage->m_pDocument, usage);
 
   CFX_Matrix matrix;
   pPage->GetDisplayMatrix(matrix, start_x, start_y, size_x, size_y, rotate);
 
   pContext->m_pDevice->SaveState();
   pContext->m_pDevice->SetClip_Rect(
       FX_RECT(start_x, start_y, start_x + size_x, start_y + size_y));
 
-  pContext->m_pContext = WrapUnique(new CPDF_RenderContext(pPage));
+  pContext->m_pContext = pdfium::MakeUnique<CPDF_RenderContext>(pPage);
   pContext->m_pContext->AppendLayer(pPage, &matrix);
 
   if (flags & FPDF_ANNOT) {
-    pContext->m_pAnnots = WrapUnique(new CPDF_AnnotList(pPage));
+    pContext->m_pAnnots = pdfium::MakeUnique<CPDF_AnnotList>(pPage);
     FX_BOOL bPrinting = pContext->m_pDevice->GetDeviceClass() != FXDC_DISPLAY;
     pContext->m_pAnnots->DisplayAnnots(pPage, pContext->m_pContext.get(),
                                        bPrinting, &matrix, FALSE, nullptr);
   }
 
-  pContext->m_pRenderer = WrapUnique(new CPDF_ProgressiveRenderer(
+  pContext->m_pRenderer = pdfium::MakeUnique<CPDF_ProgressiveRenderer>(
       pContext->m_pContext.get(), pContext->m_pDevice.get(),
-      pContext->m_pOptions.get()));
+      pContext->m_pOptions.get());
   pContext->m_pRenderer->Start(pause);
   if (bNeedToRestore)
     pContext->m_pDevice->RestoreState(false);
 }
 
 DLLEXPORT int STDCALL FPDF_GetPageSizeByIndex(FPDF_DOCUMENT document,
                                               int page_index,
                                               double* width,
                                               double* height) {
   UnderlyingDocumentType* pDoc = UnderlyingFromFPDFDocument(document);
@@ skipping 213 matching lines @@
   if (!buffer) {
     *buflen = len;
   } else if (*buflen >= len) {
     memcpy(buffer, utf16Name.c_str(), len);
     *buflen = len;
   } else {
     *buflen = -1;
   }
   return (FPDF_DEST)pDestObj;
 }