fix last warnings on w64 and turn on w.a.e.

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 367 matching lines @@
         //overlap is certain, use memmove
         memmove(fontPackageBuffer.get() + extra, fontPackageBuffer.get(), bytesWritten);
 
         // Write the ttc header.
         SkTTCFHeader* ttcfHeader = reinterpret_cast<SkTTCFHeader*>(fontPackageBuffer.get());
         ttcfHeader->ttcTag = SkTTCFHeader::TAG;
         ttcfHeader->version = SkTTCFHeader::version_1;
         ttcfHeader->numOffsets = SkEndian_SwapBE32(ttcCount);
         SK_OT_ULONG* offsetPtr = SkTAfter<SK_OT_ULONG>(ttcfHeader);
         for (int i = 0; i < ttcCount; ++i, ++offsetPtr) {
-            *offsetPtr = SkEndian_SwapBE32(extra);
+            *offsetPtr = SkEndian_SwapBE32(SkToU32(extra));
         }
 
         // Fix up offsets in sfnt table entries.
         SkSFNTHeader* sfntHeader = SkTAddOffset<SkSFNTHeader>(fontPackageBuffer.get(), extra);
         int numTables = SkEndian_SwapBE16(sfntHeader->numTables);
         SkSFNTHeader::TableDirectoryEntry* tableDirectory =
             SkTAfter<SkSFNTHeader::TableDirectoryEntry>(sfntHeader);
         for (int i = 0; i < numTables; ++i, ++tableDirectory) {
             tableDirectory->offset = SkEndian_SwapBE32(
-                SkEndian_SwapBE32(tableDirectory->offset) + extra);
+                SkToU32(SkEndian_SwapBE32(SkToU32(tableDirectory->offset)) + extra));
         }
     } else {
         extra = 0;
         fontPackageBuffer.realloc(bytesWritten);
     }
 
     SkAutoTUnref<SkMemoryStream> newStream(new SkMemoryStream());
     newStream->setMemoryOwned(fontPackageBuffer.detach(), bytesWritten + extra);
 
     SkTScopedComPtr<IStream> newIStream;
@@ skipping 1658 matching lines @@
         xpsGlyph->verticalOffset = (SkFixedToFloat(y) * -procs->centemPerUnit)
                                    - first.verticalOffset;
     }
 }
 
 static void text_draw_init(const SkPaint& paint,
                            const void* text, size_t byteLength,
                            SkBitSet& glyphsUsed,
                            SkDraw& myDraw, SkXPSDrawProcs& procs) {
     procs.fD1GProc = xps_draw_1_glyph;
-    size_t numGlyphGuess;
+    int numGlyphGuess;
     switch (paint.getTextEncoding()) {
         case SkPaint::kUTF8_TextEncoding:
             numGlyphGuess = SkUTF8_CountUnichars(
                 static_cast<const char *>(text),
                 byteLength);
             break;
         case SkPaint::kUTF16_TextEncoding:
             numGlyphGuess = SkUTF16_CountUnichars(
                 static_cast<const uint16_t *>(text),
-                byteLength);
+                SkToInt(byteLength));
             break;
         case SkPaint::kGlyphID_TextEncoding:
-            numGlyphGuess = byteLength / 2;
+            numGlyphGuess = SkToInt(byteLength / 2);
             break;
         default:
             SK_ALWAYSBREAK(true);
     }
     procs.xpsGlyphs.setReserve(numGlyphGuess);
     procs.glyphUse = &glyphsUsed;
     procs.centemPerUnit = 100.0f / SkScalarToFLOAT(paint.getTextSize());
 
     myDraw.fProcs = &procs;
 }
@@ skipping 168 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;
 }