Add testing flag for XPS for deterministic ids.

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.
  */
 
 #ifndef UNICODE
 #define UNICODE
 #endif
@@ skipping 12 matching lines @@
 #include "SkDraw.h"
 #include "SkDrawProcs.h"
 #include "SkEndian.h"
 #include "SkFontHost.h"
 #include "SkGlyphCache.h"
 #include "SkHRESULT.h"
 #include "SkImageEncoder.h"
 #include "SkIStream.h"
 #include "SkMaskFilter.h"
 #include "SkPaint.h"
+#include "SkPathOps.h"
 #include "SkPoint.h"
 #include "SkRasterizer.h"
 #include "SkSFNTHeader.h"
 #include "SkShader.h"
 #include "SkSize.h"
 #include "SkStream.h"
 #include "SkTDArray.h"
 #include "SkTLazy.h"
 #include "SkTScopedComPtr.h"
 #include "SkTTCFHeader.h"
 #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 create_id.
+//Dummy representation of a GUID from createId.
 #define L_GUID_ID L"XXXXXXXXsXXXXsXXXXsXXXXsXXXXXXXXXXXX"
-//Length of GUID representation from create_id, including NULL terminator.
+//Length of GUID representation from createId, including NULL 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 13 matching lines @@
                       guid.Data4[1],
                       sep,
                       guid.Data4[2],
                       guid.Data4[3],
                       guid.Data4[4],
                       guid.Data4[5],
                       guid.Data4[6],
                       guid.Data4[7]);
 }
 
-/**
-   Creates a GUID based id 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
-   The string may begin with a digit,
-   and so may not be suitable as a bare resource key.
- */
-static HRESULT create_id(wchar_t* buffer, size_t bufferSize,
-                         wchar_t sep = '-') {
+HRESULT SkXPSDevice::createId(wchar_t* buffer, size_t bufferSize, wchar_t sep) {
     GUID guid = {};
+#ifdef SK_XPS_USE_DETERMINISTIC_IDS
+    guid.Data1 = fNextId++;
+    // The following make this a valid Type4 UUID.
+    guid.Data3 = 0x4000;
+    guid.Data4[0] = 0x80;
+#else
     HRM(CoCreateGuid(&guid), "Could not create GUID for id.");
+#endif
 
     if (format_guid(guid, buffer, bufferSize, sep) == -1) {
         HRM(E_UNEXPECTED, "Could not format GUID into id.");
     }
 
     return S_OK;
 }
 
 static SkBitmap make_fake_bitmap(int width, int height) {
     SkBitmap bitmap;
@@ skipping 77 matching lines @@
     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];
     if (pageNum > 0) {
         swprintf_s(buffer, size, L"/Documents/1/Metadata/%u.png", pageNum);
     } else {
         wchar_t id[GUID_ID_LEN];
-        HR(create_id(id, GUID_ID_LEN));
+        HR(this->createId(id, GUID_ID_LEN));
         swprintf_s(buffer, size, L"/Metadata/%s.png", id);
     }
     HRM(this->fXpsFactory->CreatePartUri(buffer, &partUri),
         "Could not create thumbnail part uri.");
 
     HRM(thumbnailGenerator->GenerateThumbnail(page,
                                               XPS_IMAGE_TYPE_PNG,
                                               XPS_THUMBNAIL_SIZE_LARGE,
                                               partUri.get(),
                                               image),
@@ skipping 433 matching lines @@
     SkMemoryStream* read = new SkMemoryStream;
     read->setData(write.copyToData())->unref();
     SkTScopedComPtr<IStream> readWrapper;
     HRM(SkIStream::CreateFromSkStream(read, true, &readWrapper),
         "Could not create stream from png data.");
 
     const size_t size =
         SK_ARRAY_COUNT(L"/Documents/1/Resources/Images/" L_GUID_ID L".png");
     wchar_t buffer[size];
     wchar_t id[GUID_ID_LEN];
-    HR(create_id(id, GUID_ID_LEN));
+    HR(this->createId(id, GUID_ID_LEN));
     swprintf_s(buffer, size, L"/Documents/1/Resources/Images/%s.png", id);
 
     SkTScopedComPtr<IOpcPartUri> imagePartUri;
     HRM(this->fXpsFactory->CreatePartUri(buffer, &imagePartUri),
         "Could not create image part uri.");
 
     SkTScopedComPtr<IXpsOMImageResource> imageResource;
     HRM(this->fXpsFactory->CreateImageResource(
             readWrapper.get(),
             XPS_IMAGE_TYPE_PNG,
@@ skipping 769 matching lines @@
     //Save the old canvas to a dictionary on the new canvas.
     SkTScopedComPtr<IXpsOMDictionary> newDictionary;
     HRM(this->fXpsFactory->CreateDictionary(&newDictionary),
         "Could not create inverse dictionary.");
     HRM(newCanvas->SetDictionaryLocal(newDictionary.get()),
         "Could not set inverse dictionary.");
 
     const size_t size = SK_ARRAY_COUNT(L"ID" L_GUID_ID);
     wchar_t buffer[size];
     wchar_t id[GUID_ID_LEN];
-    HR(create_id(id, GUID_ID_LEN, '_'));
+    HR(this->createId(id, GUID_ID_LEN, '_'));
     swprintf_s(buffer, size, L"ID%s", id);
     HRM(newDictionary->Append(buffer, this->fCurrentXpsCanvas.get()),
         "Could not add canvas to inverse dictionary.");
 
     //Start drawing
     SkTScopedComPtr<IXpsOMVisualCollection> newVisuals;
     HRM(newCanvas->GetVisuals(&newVisuals),
         "Could not get inverse canvas visuals.");
 
     //Draw old canvas from dictionary onto new canvas.
@@ skipping 600 matching lines @@
     int ttcIndex;
     SkStream* fontData = typeface->openStream(&ttcIndex);
     //TODO: cannot handle FON fonts.
     HRM(SkIStream::CreateFromSkStream(fontData, true, &fontStream),
         "Could not create font stream.");
 
     const size_t size =
         SK_ARRAY_COUNT(L"/Resources/Fonts/" L_GUID_ID L".odttf");
     wchar_t buffer[size];
     wchar_t id[GUID_ID_LEN];
-    HR(create_id(id, GUID_ID_LEN));
+    HR(this->createId(id, GUID_ID_LEN));
     swprintf_s(buffer, size, L"/Resources/Fonts/%s.odttf", id);
 
     SkTScopedComPtr<IOpcPartUri> partUri;
     HRM(this->fXpsFactory->CreatePartUri(buffer, &partUri),
         "Could not create font resource part uri.");
 
     SkTScopedComPtr<IXpsOMFontResource> xpsFontResource;
     HRM(this->fXpsFactory->CreateFontResource(fontStream.get(),
                                               embedding,
                                               partUri.get(),
@@ skipping 359 matching lines @@
              IID_PPV_ARGS(&this->fXpsFactory)),
          "Could not create factory for layer.");
 
     HRVM(this->fXpsFactory->CreateCanvas(&this->fCurrentXpsCanvas),
          "Could not create canvas for layer.");
 }
 
 bool SkXPSDevice::allowImageFilter(const SkImageFilter*) {
     return false;
 }