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>
 
@@ skipping 11 matching lines @@
   (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);

[dsinclair, 2016/03/16 13:23:31]

Can you add a TODO, this seems broken. OPJ_SIZE is a typedef for size_t. size_t
is a unsigned data type. We probably shouldn't be using -1 as a sentinal value
in that case.

[Wei Li, 2016/03/16 17:51:31]

Done.

[Tom Sepez, 2016/03/16 18:34:58]

Probably ok along the lines of std::string::npos's usage of the same technique.

[Wei Li, 2016/03/17 02:24:05]

Ack. I digged deeper and found that this is required/used by libopenjpeg code.

[Tom Sepez, 2016/03/17 16:40:05]

Acknowledged.

   }
   // 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);
@@ skipping 804 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;
 }