Style Change: NULL->nullptr

src/device/xps/SkXPSDevice.cpp

 /*
  * Copyright 2011 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkTypes.h"
 
 #ifndef UNICODE
@@ skipping 34 matching lines @@
 #include "SkTypefacePriv.h"
 #include "SkUtils.h"
 #include "SkXPSDevice.h"
 
 //Windows defines a FLOAT type,
 //make it clear when converting a scalar that this is what is wanted.
 #define SkScalarToFLOAT(n) SkScalarToFloat(n)
 
 //Dummy representation of a GUID from createId.
 #define L_GUID_ID L"XXXXXXXXsXXXXsXXXXsXXXXsXXXXXXXXXXXX"
-//Length of GUID representation from createId, including NULL terminator.
+//Length of GUID representation from createId, including nullptr terminator.
 #define GUID_ID_LEN SK_ARRAY_COUNT(L_GUID_ID)
 
 /**
    Formats a GUID and places it into buffer.
    buffer should have space for at least GUID_ID_LEN wide characters.
    The string will always be wchar null terminated.
    XXXXXXXXsXXXXsXXXXsXXXXsXXXXXXXXXXXX0
    @return -1 if there was an error, > 0 if success.
  */
 static int format_guid(const GUID& guid,
@@ skipping 49 matching lines @@
     : INHERITED(make_fake_bitmap(10000, 10000), SkSurfaceProps(0, kUnknown_SkPixelGeometry))
     , fCurrentPage(0) {
 }
 
 SkXPSDevice::SkXPSDevice(IXpsOMObjectFactory* xpsFactory)
     : INHERITED(make_fake_bitmap(10000, 10000), SkSurfaceProps(0, kUnknown_SkPixelGeometry))
     , fCurrentPage(0) {
 
     HRVM(CoCreateInstance(
              CLSID_XpsOMObjectFactory,
-             NULL,
+             nullptr,
              CLSCTX_INPROC_SERVER,
              IID_PPV_ARGS(&this->fXpsFactory)),
          "Could not create factory for layer.");
 
     HRVM(this->fXpsFactory->CreateCanvas(&this->fCurrentXpsCanvas),
          "Could not create canvas for layer.");
 }
 
 SkXPSDevice::~SkXPSDevice() {
 }
 
 SkXPSDevice::TypefaceUse::TypefaceUse()
     : typefaceId(0xffffffff)
-    , fontData(NULL)
-    , xpsFont(NULL)
-    , glyphsUsed(NULL) {
+    , fontData(nullptr)
+    , xpsFont(nullptr)
+    , glyphsUsed(nullptr) {
 }
 
 SkXPSDevice::TypefaceUse::~TypefaceUse() {
     //xpsFont owns fontData ref
     this->xpsFont->Release();
     delete this->glyphsUsed;
 }
 
 bool SkXPSDevice::beginPortfolio(SkWStream* outputStream) {
     if (!this->fAutoCo.succeeded()) return false;
 
     //Create XPS Factory.
     HRBM(CoCreateInstance(
              CLSID_XpsOMObjectFactory,
-             NULL,
+             nullptr,
              CLSCTX_INPROC_SERVER,
              IID_PPV_ARGS(&this->fXpsFactory)),
          "Could not create XPS factory.");
 
     HRBM(SkWIStream::CreateFromSkWStream(outputStream, &this->fOutputStream),
          "Could not convert SkStream to IStream.");
 
     return true;
 }
 
@@ skipping 19 matching lines @@
 
     return true;
 }
 
 HRESULT SkXPSDevice::createXpsThumbnail(IXpsOMPage* page,
                                         const unsigned int pageNum,
                                         IXpsOMImageResource** image) {
     SkTScopedComPtr<IXpsOMThumbnailGenerator> thumbnailGenerator;
     HRM(CoCreateInstance(
             CLSID_XpsOMThumbnailGenerator,
-            NULL,
+            nullptr,
             CLSCTX_INPROC_SERVER,
             IID_PPV_ARGS(&thumbnailGenerator)),
         "Could not create thumbnail generator.");
 
     SkTScopedComPtr<IOpcPartUri> partUri;
     static const size_t size = SkTUMax<
         SK_ARRAY_COUNT(L"/Documents/1/Metadata/.png") + SK_DIGITS_IN(pageNum),
         SK_ARRAY_COUNT(L"/Metadata/" L_GUID_ID L".png")
     >::value;
     wchar_t buffer[size];
@@ skipping 43 matching lines @@
     {
         SkTScopedComPtr<IOpcPartUri> partUri;
         HRM(this->fXpsFactory->CreatePartUri(L"/FixedDocumentSequence.fdseq",
                                              &partUri),
             "Could not create document sequence part uri.");
         HRM(this->fXpsFactory->CreatePackageWriterOnStream(
                 this->fOutputStream.get(),
                 TRUE,
                 XPS_INTERLEAVING_OFF, //XPS_INTERLEAVING_ON,
                 partUri.get(),
-                NULL,
+                nullptr,
                 image,
-                NULL,
-                NULL,
+                nullptr,
+                nullptr,
                 &this->fPackageWriter),
             "Could not create package writer.");
     }
 
     //Begin the lone document.
     {
         SkTScopedComPtr<IOpcPartUri> partUri;
         HRM(this->fXpsFactory->CreatePartUri(
                 L"/Documents/1/FixedDocument.fdoc",
                 &partUri),
             "Could not create fixed document part uri.");
         HRM(this->fPackageWriter->StartNewDocument(partUri.get(),
-                                                   NULL,
-                                                   NULL,
-                                                   NULL,
-                                                   NULL),
+                                                   nullptr,
+                                                   nullptr,
+                                                   nullptr,
+                                                   nullptr),
             "Could not start document.");
     }
 
     return S_OK;
 }
 
 bool SkXPSDevice::endSheet() {
     //XPS is fixed at 96dpi (XPS Spec 11.1).
     static const float xpsDPI = 96.0f;
     static const float inchesPerMeter = 10000.0f / 254.0f;
@@ skipping 31 matching lines @@
     HRB(this->createXpsPage(pageSize, &page));
 
     SkTScopedComPtr<IXpsOMVisualCollection> pageVisuals;
     HRBM(page->GetVisuals(&pageVisuals), "Could not get page visuals.");
 
     //Add the scale canvas to the page.
     HRBM(pageVisuals->Append(scaleCanvas.get()),
          "Could not add scale canvas to page.");
 
     //Create the package writer if it hasn't been created yet.
-    if (NULL == this->fPackageWriter.get()) {
+    if (nullptr == this->fPackageWriter.get()) {
         SkTScopedComPtr<IXpsOMImageResource> image;
         //Ignore return, thumbnail is completely optional.
         this->createXpsThumbnail(page.get(), 0, &image);
 
         HRB(this->initXpsDocumentWriter(image.get()));
     }
 
     HRBM(this->fPackageWriter->AddPage(page.get(),
                                        &pageSize,
-                                       NULL,
-                                       NULL,
-                                       NULL,
-                                       NULL),
+                                       nullptr,
+                                       nullptr,
+                                       nullptr,
+                                       nullptr),
          "Could not write the page.");
     this->fCurrentXpsCanvas.reset();
 
     return true;
 }
 
 static HRESULT subset_typeface(SkXPSDevice::TypefaceUse* current) {
     //CreateFontPackage wants unsigned short.
     //Microsoft, Y U NO stdint.h?
     SkTDArray<unsigned short> keepList;
     current->glyphsUsed->exportTo(&keepList);
 
     int ttcCount = (current->ttcIndex + 1);
 
     //The following are declared with the types required by CreateFontPackage.
-    unsigned char *fontPackageBufferRaw = NULL;
+    unsigned char *fontPackageBufferRaw = nullptr;
     unsigned long fontPackageBufferSize;
     unsigned long bytesWritten;
     unsigned long result = CreateFontPackage(
         (unsigned char *) current->fontData->getMemoryBase(),
         (unsigned long) current->fontData->getLength(),
         &fontPackageBufferRaw,
         &fontPackageBufferSize,
         &bytesWritten,
         TTFCFP_FLAGS_SUBSET | TTFCFP_FLAGS_GLYPHLIST | (ttcCount > 0 ? TTFCFP_FLAGS_TTC : 0),
         current->ttcIndex,
         TTFCFP_SUBSET,
         0,
         0,
         0,
         keepList.begin(),
         keepList.count(),
         sk_malloc_throw,
         sk_realloc_throw,
         sk_free,
-        NULL);
+        nullptr);
     SkAutoTMalloc<unsigned char> fontPackageBuffer(fontPackageBufferRaw);
     if (result != NO_ERROR) {
         SkDEBUGF(("CreateFontPackage Error %lu", result));
         return E_UNEXPECTED;
     }
 
     // If it was originally a ttc, keep it a ttc.
     // CreateFontPackage over-allocates, realloc usually decreases the size substantially.
     size_t extra;
     if (ttcCount > 0) {
@@ skipping 137 matching lines @@
                              + (stopTransformed.fY - startTransformed.fY);
         //Percentage along transformed line.
         stopOffsets[i] = startToStop / startToEnd;
     }
 }
 
 HRESULT SkXPSDevice::createXpsTransform(const SkMatrix& matrix,
                                         IXpsOMMatrixTransform** xpsTransform) {
     SkScalar affine[6];
     if (!matrix.asAffine(affine)) {
-        *xpsTransform = NULL;
+        *xpsTransform = nullptr;
         return S_FALSE;
     }
     XPS_MATRIX rawXpsMatrix = {
         SkScalarToFLOAT(affine[SkMatrix::kAScaleX]),
         SkScalarToFLOAT(affine[SkMatrix::kASkewY]),
         SkScalarToFLOAT(affine[SkMatrix::kASkewX]),
         SkScalarToFLOAT(affine[SkMatrix::kAScaleY]),
         SkScalarToFLOAT(affine[SkMatrix::kATransX]),
         SkScalarToFLOAT(affine[SkMatrix::kATransY]),
     };
@@ skipping 19 matching lines @@
 
     HRM(visuals->Append(*path), "Could not add path to visuals.");
     return S_OK;
 }
 
 HRESULT SkXPSDevice::createXpsSolidColorBrush(const SkColor skColor,
                                               const SkAlpha alpha,
                                               IXpsOMBrush** xpsBrush) {
     XPS_COLOR xpsColor = xps_color(skColor);
     SkTScopedComPtr<IXpsOMSolidColorBrush> solidBrush;
-    HRM(this->fXpsFactory->CreateSolidColorBrush(&xpsColor, NULL, &solidBrush),
+    HRM(this->fXpsFactory->CreateSolidColorBrush(&xpsColor, nullptr, &solidBrush),
         "Could not create solid color brush.");
     HRM(solidBrush->SetOpacity(alpha / 255.0f), "Could not set opacity.");
     HRM(solidBrush->QueryInterface<IXpsOMBrush>(xpsBrush), "QI Fail.");
     return S_OK;
 }
 
 HRESULT SkXPSDevice::sideOfClamp(const SkRect& areaToFill,
                                  const XPS_RECT& imageViewBox,
                                  IXpsOMImageResource* image,
                                  IXpsOMVisualCollection* visuals) {
@@ skipping 244 matching lines @@
     }
 
     return S_OK;
 }
 
 HRESULT SkXPSDevice::createXpsGradientStop(const SkColor skColor,
                                            const SkScalar offset,
                                            IXpsOMGradientStop** xpsGradStop) {
     XPS_COLOR gradStopXpsColor = xps_color(skColor);
     HRM(this->fXpsFactory->CreateGradientStop(&gradStopXpsColor,
-                                              NULL,
+                                              nullptr,
                                               SkScalarToFLOAT(offset),
                                               xpsGradStop),
         "Could not create gradient stop.");
     return S_OK;
 }
 
 HRESULT SkXPSDevice::createXpsLinearGradient(SkShader::GradientInfo info,
                                              const SkAlpha alpha,
                                              const SkMatrix& localMatrix,
                                              IXpsOMMatrixTransform* xpsMatrix,
@@ skipping 129 matching lines @@
         "Could not set opacity of radial gradient brush.");
     HRM(gradientBrush->QueryInterface<IXpsOMBrush>(xpsBrush), "QI failed.");
 
     return S_OK;
 }
 
 HRESULT SkXPSDevice::createXpsBrush(const SkPaint& skPaint,
                                     IXpsOMBrush** brush,
                                     const SkMatrix* parentTransform) {
     const SkShader *shader = skPaint.getShader();
-    if (NULL == shader) {
+    if (nullptr == shader) {
         HR(this->createXpsSolidColorBrush(skPaint.getColor(), 0xFF, brush));
         return S_OK;
     }
 
     //Gradient shaders.
     SkShader::GradientInfo info;
     info.fColorCount = 0;
-    info.fColors = NULL;
-    info.fColorOffsets = NULL;
+    info.fColors = nullptr;
+    info.fColorOffsets = nullptr;
     SkShader::GradientType gradientType = shader->asAGradient(&info);
 
     if (SkShader::kNone_GradientType == gradientType) {
         //Nothing to see, move along.
 
     } else if (SkShader::kColor_GradientType == gradientType) {
         SkASSERT(1 == info.fColorCount);
         SkColor color;
         info.fColors = &color;
         shader->asAGradient(&info);
@@ skipping 180 matching lines @@
                            const SkRect& r,
                            const SkPaint& paint) {
     this->internalDrawRect(d, r, true, paint);
 }
 
 void SkXPSDevice::drawRRect(const SkDraw& d,
                             const SkRRect& rr,
                             const SkPaint& paint) {
     SkPath path;
     path.addRRect(rr);
-    this->drawPath(d, path, paint, NULL, true);
+    this->drawPath(d, path, paint, nullptr, true);
 }
 
 void SkXPSDevice::internalDrawRect(const SkDraw& d,
                                    const SkRect& r,
                                    bool transformRect,
                                    const SkPaint& paint) {
     //Exit early if there is nothing to draw.
     if (d.fClip->isEmpty() ||
-        (paint.getAlpha() == 0 && paint.getXfermode() == NULL)) {
+        (paint.getAlpha() == 0 && paint.getXfermode() == nullptr)) {
         return;
     }
 
     //Path the rect if we can't optimize it.
     if (rect_must_be_pathed(paint, *d.fMatrix)) {
         SkPath tmp;
         tmp.addRect(r);
         tmp.setFillType(SkPath::kWinding_FillType);
-        this->drawPath(d, tmp, paint, NULL, true);
+        this->drawPath(d, tmp, paint, nullptr, true);
         return;
     }
 
     //Create the shaded path.
     SkTScopedComPtr<IXpsOMPath> shadedPath;
     HRVM(this->fXpsFactory->CreatePath(&shadedPath),
          "Could not create shaded path for rect.");
 
     //Create the shaded geometry.
     SkTScopedComPtr<IXpsOMGeometry> shadedGeometry;
@@ skipping 286 matching lines @@
 
 void SkXPSDevice::drawPath(const SkDraw& d,
                            const SkPath& platonicPath,
                            const SkPaint& origPaint,
                            const SkMatrix* prePathMatrix,
                            bool pathIsMutable) {
     SkTCopyOnFirstWrite<SkPaint> paint(origPaint);
 
     // nothing to draw
     if (d.fClip->isEmpty() ||
-        (paint->getAlpha() == 0 && paint->getXfermode() == NULL)) {
+        (paint->getAlpha() == 0 && paint->getXfermode() == nullptr)) {
         return;
     }
 
     SkPath modifiedPath;
     const bool paintHasPathEffect = paint->getPathEffect()
                                  || paint->getStyle() != SkPaint::kFill_Style;
 
     //Apply pre-path matrix [Platonic-path -> Skeletal-path].
     SkMatrix matrix = *d.fMatrix;
     SkPath* skeletalPath = const_cast<SkPath*>(&platonicPath);
@@ skipping 12 matching lines @@
     //Apply path effect [Skeletal-path -> Fillable-path].
     SkPath* fillablePath = skeletalPath;
     if (paintHasPathEffect) {
         if (!pathIsMutable) {
             fillablePath = &modifiedPath;
             pathIsMutable = true;
         }
         bool fill = paint->getFillPath(*skeletalPath, fillablePath);
 
         SkPaint* writablePaint = paint.writable();
-        writablePaint->setPathEffect(NULL);
+        writablePaint->setPathEffect(nullptr);
         if (fill) {
             writablePaint->setStyle(SkPaint::kFill_Style);
         } else {
             writablePaint->setStyle(SkPaint::kStroke_Style);
             writablePaint->setStrokeWidth(0);
         }
     }
 
     //Create the shaded path. This will be the path which is painted.
     SkTScopedComPtr<IXpsOMPath> shadedPath;
@@ skipping 31 matching lines @@
     //Rasterizer
     if (rasterizer) {
         SkIRect clipIRect;
         SkVector ppuScale;
         this->convertToPpm(filter,
                            &matrix,
                            &ppuScale,
                            d.fClip->getBounds(),
                            &clipIRect);
 
-        SkMask* mask = NULL;
+        SkMask* mask = nullptr;
 
         //[Fillable-path -> Mask]
         SkMask rasteredMask;
         if (rasterizer->rasterize(
                 *fillablePath,
                 matrix,
                 &clipIRect,
                 filter,  //just to compute how much to draw.
                 &rasteredMask,
                 SkMask::kComputeBoundsAndRenderImage_CreateMode)) {
 
             SkAutoMaskFreeImage rasteredAmi(rasteredMask.fImage);
             mask = &rasteredMask;
 
             //[Mask -> Mask]
             SkMask filteredMask;
             if (filter &&
-                filter->filterMask(&filteredMask, *mask, *d.fMatrix, NULL)) {
+                filter->filterMask(&filteredMask, *mask, *d.fMatrix, nullptr)) {
 
                 mask = &filteredMask;
             } else {
-                filteredMask.fImage = NULL;
+                filteredMask.fImage = nullptr;
             }
             SkAutoMaskFreeImage filteredAmi(filteredMask.fImage);
 
             //Draw mask.
             HRV(this->applyMask(d, *mask, ppuScale, shadedPath.get()));
         }
         return;
     }
 
     //Mask filter
     if (filter) {
         SkIRect clipIRect;
         SkVector ppuScale;
         this->convertToPpm(filter,
                            &matrix,
                            &ppuScale,
                            d.fClip->getBounds(),
                            &clipIRect);
 
         //[Fillable-path -> Pixel-path]
         SkPath* pixelPath = pathIsMutable ? fillablePath : &modifiedPath;
         fillablePath->transform(matrix, pixelPath);
 
-        SkMask* mask = NULL;
+        SkMask* mask = nullptr;
 
         //[Pixel-path -> Mask]
         SkMask rasteredMask;
         if (SkDraw::DrawToMask(
                         *pixelPath,
                         &clipIRect,
                         filter,  //just to compute how much to draw.
                         &matrix,
                         &rasteredMask,
                         SkMask::kComputeBoundsAndRenderImage_CreateMode,
                         paint->getStyle())) {
 
             SkAutoMaskFreeImage rasteredAmi(rasteredMask.fImage);
             mask = &rasteredMask;
 
             //[Mask -> Mask]
             SkMask filteredMask;
             if (filter->filterMask(&filteredMask,
                                    rasteredMask,
                                    matrix,
-                                   NULL)) {
+                                   nullptr)) {
                 mask = &filteredMask;
             } else {
-                filteredMask.fImage = NULL;
+                filteredMask.fImage = nullptr;
             }
             SkAutoMaskFreeImage filteredAmi(filteredMask.fImage);
 
             //Draw mask.
             HRV(this->applyMask(d, *mask, ppuScale, shadedPath.get()));
         }
         return;
     }
 
     //Get the figures from the shaded geometry.
@@ skipping 303 matching lines @@
         HRM(glyphsEditor->SetGlyphIndices(xpsGlyphsLen, xpsGlyphs),
             "Could not set glyphs.");
     }
 
     HRM(glyphsEditor->ApplyEdits(), "Could not apply glyph edits.");
 
     SkTScopedComPtr<IXpsOMBrush> xpsFillBrush;
     HR(this->createXpsBrush(
             paint,
             &xpsFillBrush,
-            useCanvasForClip ? NULL : &transform));
+            useCanvasForClip ? nullptr : &transform));
 
     HRM(glyphs->SetFillBrushLocal(xpsFillBrush.get()),
         "Could not set fill brush.");
 
     HRM(glyphs->SetOrigin(origin), "Could not set glyph origin.");
 
     HRM(glyphs->SetFontRenderingEmSize(fontSize),
         "Could not set font size.");
 
     HRM(glyphs->SetStyleSimulations(sims),
@@ skipping 107 matching lines @@
 
 void SkXPSDevice::drawText(const SkDraw& d,
                            const void* text, size_t byteLen,
                            SkScalar x, SkScalar y,
                            const SkPaint& paint) {
     if (byteLen < 1) return;
 
     if (text_must_be_pathed(paint, *d.fMatrix)) {
         SkPath path;
         paint.getTextPath(text, byteLen, x, y, &path);
-        this->drawPath(d, path, paint, NULL, true);
+        this->drawPath(d, path, paint, nullptr, true);
         //TODO: add automation "text"
         return;
     }
 
     TypefaceUse* typeface;
     HRV(CreateTypefaceUse(paint, &typeface));
 
     SkDraw myDraw(d);
     myDraw.fMatrix = &SkMatrix::I();
     SkXPSDrawProcs procs;
@@ skipping 10 matching lines @@
         procs.xpsGlyphs[0].horizontalOffset / procs.centemPerUnit,
         procs.xpsGlyphs[0].verticalOffset / -procs.centemPerUnit,
     };
     procs.xpsGlyphs[0].horizontalOffset = 0.0f;
     procs.xpsGlyphs[0].verticalOffset = 0.0f;
 
     HRV(AddGlyphs(d,
                   this->fXpsFactory.get(),
                   this->fCurrentXpsCanvas.get(),
                   typeface,
-                  NULL,
+                  nullptr,
                   procs.xpsGlyphs.begin(), procs.xpsGlyphs.count(),
                   &origin,
                   SkScalarToFLOAT(paint.getTextSize()),
                   XPS_STYLE_SIMULATION_NONE,
                   *d.fMatrix,
                   paint));
 }
 
 void SkXPSDevice::drawPosText(const SkDraw& d,
                               const void* text, size_t byteLen,
                               const SkScalar pos[], int scalarsPerPos,
                               const SkPoint& offset, const SkPaint& paint) {
     if (byteLen < 1) return;
 
     if (text_must_be_pathed(paint, *d.fMatrix)) {
         SkPath path;
         //TODO: make this work, Draw currently does not handle as well.
         //paint.getTextPath(text, byteLength, x, y, &path);
-        //this->drawPath(d, path, paint, NULL, true);
+        //this->drawPath(d, path, paint, nullptr, true);
         //TODO: add automation "text"
         return;
     }
 
     TypefaceUse* typeface;
     HRV(CreateTypefaceUse(paint, &typeface));
 
     SkDraw myDraw(d);
     myDraw.fMatrix = &SkMatrix::I();
     SkXPSDrawProcs procs;
@@ skipping 10 matching lines @@
         procs.xpsGlyphs[0].horizontalOffset / procs.centemPerUnit,
         procs.xpsGlyphs[0].verticalOffset / -procs.centemPerUnit,
     };
     procs.xpsGlyphs[0].horizontalOffset = 0.0f;
     procs.xpsGlyphs[0].verticalOffset = 0.0f;
 
     HRV(AddGlyphs(d,
                   this->fXpsFactory.get(),
                   this->fCurrentXpsCanvas.get(),
                   typeface,
-                  NULL,
+                  nullptr,
                   procs.xpsGlyphs.begin(), procs.xpsGlyphs.count(),
                   &origin,
                   SkScalarToFLOAT(paint.getTextSize()),
                   XPS_STYLE_SIMULATION_NONE,
                   *d.fMatrix,
                   paint));
 }
 
 void SkXPSDevice::drawDevice(const SkDraw& d, SkBaseDevice* dev,
                              int x, int y,
@@ skipping 19 matching lines @@
     HRVM(this->fCurrentXpsCanvas->GetVisuals(&currentVisuals),
          "Could not get current visuals for layer.");
     HRVM(currentVisuals->Append(that->fCurrentXpsCanvas.get()),
          "Could not add layer to current visuals.");
 }
 
 SkBaseDevice* SkXPSDevice::onCreateDevice(const CreateInfo& info, const SkPaint*) {
 //Conditional for bug compatibility with PDF device.
 #if 0
     if (SkBaseDevice::kGeneral_Usage == info.fUsage) {
-        return NULL;
+        return nullptr;
         SK_CRASH();
         //To what stream do we write?
         //SkXPSDevice* dev = new SkXPSDevice(this);
         //SkSize s = SkSize::Make(width, height);
         //dev->BeginCanvas(s, s, SkMatrix::I());
         //return dev;
     }
 #endif
     return new SkXPSDevice(this->fXpsFactory.get());
 }