Fix Windows build

src/codec/SkRawCodec.cpp

 /*
  * Copyright 2016 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkCodec.h"
 #include "SkCodecPriv.h"
 #include "SkColorPriv.h"
@@ skipping 24 matching lines @@
 #include <cmath>  // for std::round,floor,ceil
 #include <limits>
 
 namespace {
 
 // Caluclates the number of tiles of tile_size that fit into the area in vertical and horizontal
 // directions.
 dng_point num_tiles_in_area(const dng_point &areaSize,
                             const dng_point_real64 &tileSize) {
   // FIXME: Add a ceil_div() helper in SkCodecPriv.h
-  return dng_point((areaSize.v + tileSize.v - 1) / tileSize.v,
-                   (areaSize.h + tileSize.h - 1) / tileSize.h);
+  return dng_point(static_cast<int32>((areaSize.v + tileSize.v - 1) / tileSize.v),
+                   static_cast<int32>((areaSize.h + tileSize.h - 1) / tileSize.h));
 }
 
 int num_tasks_required(const dng_point& tilesInTask,
                          const dng_point& tilesInArea) {
   return ((tilesInArea.v + tilesInTask.v - 1) / tilesInTask.v) *
          ((tilesInArea.h + tilesInTask.h - 1) / tilesInTask.h);
 }
 
 // Calculate the number of tiles to process per task, taking into account the maximum number of
 // tasks. It prefers to increase horizontally for better locality of reference.
@@ skipping 28 matching lines @@
       taskArea.r = Min_int32(taskArea.l + taskAreaSize.h, area.r);
 
       taskAreas.push_back(taskArea);
     }
   }
   return taskAreas;
 }
 
 class SkDngHost : public dng_host {
 public:
-    using dng_host::dng_host;
+    explicit SkDngHost(dng_memory_allocator* allocater) : dng_host(allocater) {}
 
     void PerformAreaTask(dng_area_task& task, const dng_rect& area) override {
         // The area task gets split up into max_tasks sub-tasks. The max_tasks is defined by the
         // dng-sdks default implementation of dng_area_task::MaxThreads() which returns 8 or 32
         // sub-tasks depending on the architecture.
         const int maxTasks = static_cast<int>(task.MaxThreads());
 
         SkTaskGroup taskGroup;
 
         // tileSize is typically 256x256
         const dng_point tileSize(task.FindTileSize(area));
         const std::vector<dng_rect> taskAreas = compute_task_areas(maxTasks, area, tileSize);
-        const int numTasks = taskAreas.size();
+        const int numTasks = static_cast<int>(taskAreas.size());
 
         task.Start(numTasks, tileSize, &Allocator(), Sniffer());
         for (int taskIndex = 0; taskIndex < numTasks; ++taskIndex) {
             taskGroup.add([&task, this, taskIndex, taskAreas, tileSize] {
                 task.ProcessOnThread(taskIndex, taskAreas[taskIndex], tileSize, this->Sniffer());
             });
         }
 
         taskGroup.wait();
         task.Finish(numTasks);
@@ skipping 440 matching lines @@
     SkISize sizeFloor = this->onGetScaledDimensions(1.f / std::floor(fullShortEdge / shortEdge));
     SkISize sizeCeil = this->onGetScaledDimensions(1.f / std::ceil(fullShortEdge / shortEdge));
     return sizeFloor == dim || sizeCeil == dim;
 }
 
 SkRawCodec::~SkRawCodec() {}
 
 SkRawCodec::SkRawCodec(SkDngImage* dngImage)
     : INHERITED(dngImage->getImageInfo(), nullptr)
     , fDngImage(dngImage) {}