Re-enable several MSVC warnings

core/fxcodec/codec/fx_codec_jpx_opj.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 <algorithm>
 #include <limits>
 #include <vector>
 
 #include "core/fxcodec/codec/codec_int.h"
 #include "core/include/fpdfapi/fpdf_resource.h"
 #include "core/include/fxcodec/fx_codec.h"
 #include "core/include/fxcrt/fx_safe_types.h"
 #include "third_party/lcms2-2.6/include/lcms2.h"
 #include "third_party/libopenjpeg20/openjpeg.h"
 
 static void fx_error_callback(const char* msg, void* client_data) {
   (void)client_data;
 }
 static void fx_warning_callback(const char* msg, void* client_data) {
   (void)client_data;
 }
 static void fx_info_callback(const char* msg, void* client_data) {
   (void)client_data;
 }
+
 OPJ_SIZE_T opj_read_from_memory(void* p_buffer,
                                 OPJ_SIZE_T nb_bytes,
                                 void* p_user_data) {
   DecodeData* srcData = static_cast<DecodeData*>(p_user_data);
   if (!srcData || !srcData->src_data || srcData->src_size == 0) {
-    return -1;
+    return static_cast<OPJ_SIZE_T>(-1);
   }
   // Reads at EOF return an error code.
   if (srcData->offset >= srcData->src_size) {
-    return -1;
+    return static_cast<OPJ_SIZE_T>(-1);
   }
   OPJ_SIZE_T bufferLength = srcData->src_size - srcData->offset;
   OPJ_SIZE_T readlength = nb_bytes < bufferLength ? nb_bytes : bufferLength;
   memcpy(p_buffer, &srcData->src_data[srcData->offset], readlength);
   srcData->offset += readlength;
   return readlength;
 }
+
 OPJ_SIZE_T opj_write_from_memory(void* p_buffer,
                                  OPJ_SIZE_T nb_bytes,
                                  void* p_user_data) {
   DecodeData* srcData = static_cast<DecodeData*>(p_user_data);
   if (!srcData || !srcData->src_data || srcData->src_size == 0) {
-    return -1;
+    return static_cast<OPJ_SIZE_T>(-1);
   }
   // Writes at EOF return an error code.
   if (srcData->offset >= srcData->src_size) {
-    return -1;
+    return static_cast<OPJ_SIZE_T>(-1);
   }
   OPJ_SIZE_T bufferLength = srcData->src_size - srcData->offset;
   OPJ_SIZE_T writeLength = nb_bytes < bufferLength ? nb_bytes : bufferLength;
   memcpy(&srcData->src_data[srcData->offset], p_buffer, writeLength);
   srcData->offset += writeLength;
   return writeLength;
 }
+
 OPJ_OFF_T opj_skip_from_memory(OPJ_OFF_T nb_bytes, void* p_user_data) {
   DecodeData* srcData = static_cast<DecodeData*>(p_user_data);
   if (!srcData || !srcData->src_data || srcData->src_size == 0) {
-    return -1;
+    return static_cast<OPJ_OFF_T>(-1);
   }
   // Offsets are signed and may indicate a negative skip. Do not support this
   // because of the strange return convention where either bytes skipped or
   // -1 is returned. Following that convention, a successful relative seek of
   // -1 bytes would be required to to give the same result as the error case.
   if (nb_bytes < 0) {
-    return -1;
+    return static_cast<OPJ_OFF_T>(-1);
   }
   // FIXME: use std::make_unsigned<OPJ_OFF_T>::type once c++11 lib is OK'd.
   uint64_t unsignedNbBytes = static_cast<uint64_t>(nb_bytes);
   // Additionally, the offset may take us beyond the range of a size_t (e.g.
   // 32-bit platforms). If so, just clamp at EOF.
   if (unsignedNbBytes >
       std::numeric_limits<OPJ_SIZE_T>::max() - srcData->offset) {
     srcData->offset = srcData->src_size;
   } else {
     OPJ_SIZE_T checkedNbBytes = static_cast<OPJ_SIZE_T>(unsignedNbBytes);
     // Otherwise, mimic fseek() semantics to always succeed, even past EOF,
     // clamping at EOF.  We can get away with this since we don't actually
     // provide negative relative skips from beyond EOF back to inside the
     // data, which would be the only reason to need to know exactly how far
     // beyond EOF we are.
     srcData->offset =
         std::min(srcData->offset + checkedNbBytes, srcData->src_size);
   }
   return nb_bytes;
 }
+
 OPJ_BOOL opj_seek_from_memory(OPJ_OFF_T nb_bytes, void* p_user_data) {
   DecodeData* srcData = static_cast<DecodeData*>(p_user_data);
   if (!srcData || !srcData->src_data || srcData->src_size == 0) {
     return OPJ_FALSE;
   }
   // Offsets are signed and may indicate a negative position, which would
   // be before the start of the file. Do not support this.
   if (nb_bytes < 0) {
     return OPJ_FALSE;
   }
@@ skipping 784 matching lines @@
 bool CCodec_JpxModule::Decode(CJPX_Decoder* pDecoder,
                               uint8_t* dest_data,
                               int pitch,
                               const std::vector<uint8_t>& offsets) {
   return pDecoder->Decode(dest_data, pitch, offsets);
 }
 
 void CCodec_JpxModule::DestroyDecoder(CJPX_Decoder* pDecoder) {
   delete pDecoder;
 }