Merge to XFA: Switch from nonstd::unique_ptr to std::unique_ptr.

core/src/fpdfapi/fpdf_render/fpdf_render_image.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 "render_int.h"
 
 #include <utility>
 #include <vector>
@@ skipping 89 matching lines @@
       }
       if (bClone) {
         delete pClone;
       }
     }
     return;
   }
   int back_left, back_top;
   FX_RECT rect(left, top, left + pDIBitmap->GetWidth(),
                top + pDIBitmap->GetHeight());
-  nonstd::unique_ptr<CFX_DIBitmap> pBackdrop(
+  std::unique_ptr<CFX_DIBitmap> pBackdrop(
       GetBackdrop(m_pCurObj, rect, back_left, back_top,
                   blend_mode > FXDIB_BLEND_NORMAL && bIsolated));
   if (!pBackdrop)
     return;
 
   if (!pDIBitmap->IsAlphaMask()) {
     pBackdrop->CompositeBitmap(left - back_left, top - back_top,
                                pDIBitmap->GetWidth(), pDIBitmap->GetHeight(),
                                pDIBitmap, 0, 0, blend_mode);
   } else {
     pBackdrop->CompositeMask(left - back_left, top - back_top,
                              pDIBitmap->GetWidth(), pDIBitmap->GetHeight(),
                              pDIBitmap, mask_argb, 0, 0, blend_mode);
   }
 
-  nonstd::unique_ptr<CFX_DIBitmap> pBackdrop1(new CFX_DIBitmap);
+  std::unique_ptr<CFX_DIBitmap> pBackdrop1(new CFX_DIBitmap);
   pBackdrop1->Create(pBackdrop->GetWidth(), pBackdrop->GetHeight(),
                      FXDIB_Rgb32);
   pBackdrop1->Clear((FX_DWORD)-1);
   pBackdrop1->CompositeBitmap(0, 0, pBackdrop->GetWidth(),
                               pBackdrop->GetHeight(), pBackdrop.get(), 0, 0);
   pBackdrop = std::move(pBackdrop1);
   m_pDevice->SetDIBits(pBackdrop.get(), back_left, back_top);
 }
 
 CPDF_TransferFunc::CPDF_TransferFunc(CPDF_Document* pDoc) : m_pPDFDoc(pDoc) {}
@@ skipping 616 matching lines @@
       !(m_pRenderStatus->m_pDevice->GetRenderCaps() & FXRC_BLEND_MODE)) {
     m_Result = FALSE;
     return TRUE;
   }
   FX_RECT clip_box = m_pRenderStatus->m_pDevice->GetClipBox();
   FX_RECT dest_rect = clip_box;
   dest_rect.Intersect(image_rect);
   FX_RECT dest_clip(
       dest_rect.left - image_rect.left, dest_rect.top - image_rect.top,
       dest_rect.right - image_rect.left, dest_rect.bottom - image_rect.top);
-  nonstd::unique_ptr<CFX_DIBitmap> pStretched(
+  std::unique_ptr<CFX_DIBitmap> pStretched(
       m_pDIBSource->StretchTo(dest_width, dest_height, m_Flags, &dest_clip));
   if (pStretched) {
     m_pRenderStatus->CompositeDIBitmap(pStretched.get(), dest_rect.left,
                                        dest_rect.top, m_FillArgb, m_BitmapAlpha,
                                        m_BlendType, FALSE);
   }
   return FALSE;
 }
 FX_BOOL CPDF_ImageRenderer::StartBitmapAlpha() {
   if (m_pDIBSource->IsOpaqueImage()) {
     CFX_PathData path;
     path.AppendRect(0, 0, 1, 1);
     path.Transform(&m_ImageMatrix);
     FX_DWORD fill_color =
         ArgbEncode(0xff, m_BitmapAlpha, m_BitmapAlpha, m_BitmapAlpha);
     m_pRenderStatus->m_pDevice->DrawPath(&path, NULL, NULL, fill_color, 0,
                                          FXFILL_WINDING);
   } else {
     const CFX_DIBSource* pAlphaMask = m_pDIBSource->IsAlphaMask()
                                           ? m_pDIBSource
                                           : m_pDIBSource->GetAlphaMask();
     if (FXSYS_fabs(m_ImageMatrix.b) >= 0.5f ||
         FXSYS_fabs(m_ImageMatrix.c) >= 0.5f) {
       int left, top;
-      nonstd::unique_ptr<CFX_DIBitmap> pTransformed(
+      std::unique_ptr<CFX_DIBitmap> pTransformed(
           pAlphaMask->TransformTo(&m_ImageMatrix, left, top));
       if (!pTransformed)
         return TRUE;
 
       m_pRenderStatus->m_pDevice->SetBitMask(
           pTransformed.get(), left, top,
           ArgbEncode(0xff, m_BitmapAlpha, m_BitmapAlpha, m_BitmapAlpha));
     } else {
       CFX_FloatRect image_rect_f = m_ImageMatrix.GetUnitRect();
       FX_RECT image_rect = image_rect_f.GetOutterRect();
@@ skipping 68 matching lines @@
     return NULL;
   }
   int width = pClipRect->right - pClipRect->left;
   int height = pClipRect->bottom - pClipRect->top;
   FX_BOOL bLuminosity = FALSE;
   bLuminosity = pSMaskDict->GetConstString("S") != "Alpha";
   CPDF_Stream* pGroup = pSMaskDict->GetStream("G");
   if (!pGroup) {
     return NULL;
   }
-  nonstd::unique_ptr<CPDF_Function> pFunc;
+  std::unique_ptr<CPDF_Function> pFunc;
   CPDF_Object* pFuncObj = pSMaskDict->GetElementValue("TR");
   if (pFuncObj && (pFuncObj->IsDictionary() || pFuncObj->IsStream()))
     pFunc.reset(CPDF_Function::Load(pFuncObj));
 
   CFX_Matrix matrix = *pMatrix;
   matrix.TranslateI(-pClipRect->left, -pClipRect->top);
   CPDF_Form form(m_pContext->m_pDocument, m_pContext->m_pPageResources, pGroup);
   form.ParseContent(NULL, NULL, NULL, NULL);
   CFX_FxgeDevice bitmap_device;
 #if _FXM_PLATFORM_ == _FXM_PLATFORM_APPLE_
@@ skipping 52 matching lines @@
   if (form.m_pFormDict) {
     pFormResource = form.m_pFormDict->GetDict("Resources");
   }
   CPDF_RenderOptions options;
   options.m_ColorMode = bLuminosity ? RENDER_COLOR_NORMAL : RENDER_COLOR_ALPHA;
   CPDF_RenderStatus status;
   status.Initialize(m_pContext, &bitmap_device, NULL, NULL, NULL, NULL,
                     &options, 0, m_bDropObjects, pFormResource, TRUE, NULL, 0,
                     pCS ? pCS->GetFamily() : 0, bLuminosity);
   status.RenderObjectList(&form, &matrix);
-  nonstd::unique_ptr<CFX_DIBitmap> pMask(new CFX_DIBitmap);
+  std::unique_ptr<CFX_DIBitmap> pMask(new CFX_DIBitmap);
   if (!pMask->Create(width, height, FXDIB_8bppMask))
     return nullptr;
 
   uint8_t* dest_buf = pMask->GetBuffer();
   int dest_pitch = pMask->GetPitch();
   uint8_t* src_buf = bitmap.GetBuffer();
   int src_pitch = bitmap.GetPitch();
   std::vector<uint8_t> transfers(256);
   if (pFunc) {
     CFX_FixedBufGrow<FX_FLOAT, 16> results(pFunc->CountOutputs());
@@ skipping 21 matching lines @@
   } else if (pFunc) {
     int size = dest_pitch * height;
     for (int i = 0; i < size; i++) {
       dest_buf[i] = transfers[src_buf[i]];
     }
   } else {
     FXSYS_memcpy(dest_buf, src_buf, dest_pitch * height);
   }
   return pMask.release();
 }