Enable size_t to int truncation warnings in PPAPI

ppapi/tests/test_file_io.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "ppapi/tests/test_file_io.h"
 
 #include <errno.h>
 #include <fcntl.h>
 #include <stdio.h>
 #include <string.h>
@@ skipping 132 matching lines @@
 }
 
 int32_t WriteEntireBuffer(PP_Instance instance,
                           pp::FileIO* file_io,
                           int32_t offset,
                           const std::string& data,
                           CallbackType callback_type) {
   TestCompletionCallback callback(instance, callback_type);
   int32_t write_offset = offset;
   const char* buf = data.c_str();
-  int32_t size = data.size();
+  int32_t size = static_cast<int32_t>(data.size());
 
   while (write_offset < offset + size) {
     callback.WaitForResult(file_io->Write(write_offset,
                                           &buf[write_offset - offset],
                                           size - write_offset + offset,
                                           callback.GetCallback()));
     if (callback.result() < 0)
       return callback.result();
     if (callback.result() == 0)
       return PP_ERROR_FAILED;
@@ skipping 610 matching lines @@
   CHECK_CALLBACK_BEHAVIOR(callback);
   ASSERT_EQ(PP_OK, callback.result());
 
   // Set up testing contents.
   int32_t rv = WriteEntireBuffer(instance_->pp_instance(), &file_io, 0,
                                  "abcdefghijkl", callback_type());
   ASSERT_EQ(PP_OK, rv);
 
   // Parallel read operations.
   const char* border = "__border__";
-  const int32_t border_size = strlen(border);
+  const int32_t border_size = static_cast<int32_t>(strlen(border));
 
   TestCompletionCallback callback_1(instance_->pp_instance(), callback_type());
   int32_t read_offset_1 = 0;
   int32_t size_1 = 3;
   std::vector<char> extended_buf_1(border_size * 2 + size_1);
   char* buf_1 = &extended_buf_1[border_size];
   memcpy(&extended_buf_1[0], border, border_size);
   memcpy(buf_1 + size_1, border, border_size);
 
   TestCompletionCallback callback_2(instance_->pp_instance(), callback_type());
@@ skipping 63 matching lines @@
                                       PP_FILEOPENFLAG_READ |
                                       PP_FILEOPENFLAG_WRITE,
                                       callback.GetCallback()));
   CHECK_CALLBACK_BEHAVIOR(callback);
   ASSERT_EQ(PP_OK, callback.result());
 
   // Parallel write operations.
   TestCompletionCallback callback_1(instance_->pp_instance(), callback_type());
   int32_t write_offset_1 = 0;
   const char* buf_1 = "abc";
-  int32_t size_1 = strlen(buf_1);
+  int32_t size_1 = static_cast<int32_t>(strlen(buf_1));
 
   TestCompletionCallback callback_2(instance_->pp_instance(), callback_type());
   int32_t write_offset_2 = size_1;
   const char* buf_2 = "defghijkl";
-  int32_t size_2 = strlen(buf_2);
+  int32_t size_2 = static_cast<int32_t>(strlen(buf_2));
 
   int32_t rv_1 = PP_OK;
   int32_t rv_2 = PP_OK;
   while (size_1 >= 0 && size_2 >= 0 && size_1 + size_2 > 0) {
     if (size_1 > 0) {
       // Copy the buffer so we can erase it below.
       std::string str_1(buf_1);
       rv_1 = file_io.Write(
-          write_offset_1, &str_1[0], str_1.size(), callback_1.GetCallback());
+          write_offset_1, &str_1[0], static_cast<int32_t>(str_1.size()),
+          callback_1.GetCallback());
       // Erase the buffer to test that async writes copy it.
       std::fill(str_1.begin(), str_1.end(), 0);
     }
     if (size_2 > 0) {
       // Copy the buffer so we can erase it below.
       std::string str_2(buf_2);
       rv_2 = file_io.Write(
-          write_offset_2, &str_2[0], str_2.size(), callback_2.GetCallback());
+          write_offset_2, &str_2[0], static_cast<int32_t>(str_2.size()),
+          callback_2.GetCallback());
       // Erase the buffer to test that async writes copy it.
       std::fill(str_2.begin(), str_2.end(), 0);
     }
 
     if (size_1 > 0) {
       callback_1.WaitForResult(rv_1);
       CHECK_CALLBACK_BEHAVIOR(callback_1);
       ASSERT_TRUE(callback_1.result() > 0);
       write_offset_1 += callback_1.result();
       buf_1 += callback_1.result();
@@ skipping 43 matching lines @@
                                       PP_FILEOPENFLAG_TRUNCATE |
                                       PP_FILEOPENFLAG_READ |
                                       PP_FILEOPENFLAG_WRITE,
                                       callback.GetCallback()));
   CHECK_CALLBACK_BEHAVIOR(callback);
   ASSERT_EQ(PP_OK, callback.result());
 
   TestCompletionCallback callback_1(instance_->pp_instance(), PP_REQUIRED);
   int32_t write_offset_1 = 0;
   const char* buf_1 = "mnopqrstuvw";
-  int32_t rv_1 = file_io.Write(write_offset_1, buf_1, strlen(buf_1),
+  int32_t rv_1 = file_io.Write(write_offset_1, buf_1,
+                               static_cast<int32_t>(strlen(buf_1)),
                                callback_1.GetCallback());
   ASSERT_EQ(PP_OK_COMPLETIONPENDING, rv_1);
 
   TestCompletionCallback callback_2(instance_->pp_instance(), callback_type());
   int32_t read_offset_2 = 4;
   char buf_2[3];
   callback_2.WaitForResult(file_io.Read(read_offset_2, buf_2, sizeof(buf_2),
                                         callback_2.GetCallback()));
   CHECK_CALLBACK_BEHAVIOR(callback_2);
   ASSERT_EQ(PP_ERROR_INPROGRESS, callback_2.result());
   callback_1.WaitForResult(rv_1);
   CHECK_CALLBACK_BEHAVIOR(callback_1);
 
   // Cannot query while a write is pending.
-  rv_1 = file_io.Write(write_offset_1, buf_1, strlen(buf_1),
+  rv_1 = file_io.Write(write_offset_1, buf_1,
+                       static_cast<int32_t>(strlen(buf_1)),
                        callback_1.GetCallback());
   ASSERT_EQ(PP_OK_COMPLETIONPENDING, rv_1);
   PP_FileInfo info;
   callback_2.WaitForResult(file_io.Query(&info, callback_2.GetCallback()));
   CHECK_CALLBACK_BEHAVIOR(callback_2);
   ASSERT_EQ(PP_ERROR_INPROGRESS, callback_2.result());
   callback_1.WaitForResult(rv_1);
   CHECK_CALLBACK_BEHAVIOR(callback_1);
 
   // Cannot touch while a write is pending.
-  rv_1 = file_io.Write(write_offset_1, buf_1, strlen(buf_1),
+  rv_1 = file_io.Write(write_offset_1, buf_1,
+                       static_cast<int32_t>(strlen(buf_1)),
                        callback_1.GetCallback());
   ASSERT_EQ(PP_OK_COMPLETIONPENDING, rv_1);
   callback_2.WaitForResult(file_io.Touch(1234.0, 5678.0,
                            callback_2.GetCallback()));
   CHECK_CALLBACK_BEHAVIOR(callback_2);
   ASSERT_EQ(PP_ERROR_INPROGRESS, callback_2.result());
   callback_1.WaitForResult(rv_1);
   CHECK_CALLBACK_BEHAVIOR(callback_1);
 
   // Cannot set length while a write is pending.
-  rv_1 = file_io.Write(write_offset_1, buf_1, strlen(buf_1),
+  rv_1 = file_io.Write(write_offset_1, buf_1,
+                       static_cast<int32_t>(strlen(buf_1)),
                        callback_1.GetCallback());
   ASSERT_EQ(PP_OK_COMPLETIONPENDING, rv_1);
   callback_2.WaitForResult(file_io.SetLength(123, callback_2.GetCallback()));
   CHECK_CALLBACK_BEHAVIOR(callback_2);
   ASSERT_EQ(PP_ERROR_INPROGRESS, callback_2.result());
   callback_1.WaitForResult(rv_1);
   CHECK_CALLBACK_BEHAVIOR(callback_1);
 
   PASS();
 }
@@ skipping 29 matching lines @@
   int fd = _open_osfhandle(reinterpret_cast<intptr_t>(handle),
                            _O_RDWR | _O_BINARY);
 #else
   int fd = handle;
 #endif
   if (fd < 0)
     return "FileIO::RequestOSFileHandle() returned a bad file descriptor.";
 
   // Check write(2) for the native FD.
   const std::string msg = "foobar";
-  ssize_t cnt = write(fd, msg.data(), msg.size());
+  ssize_t cnt = write(fd, msg.data(), static_cast<unsigned>(msg.size()));
   if (cnt < 0)
     return ReportError("write for native FD returned error", errno);
   if (cnt != static_cast<ssize_t>(msg.size()))
     return ReportError("write for native FD count mismatch", cnt);
 
   // Check lseek(2) for the native FD.
   off_t off = lseek(fd, 0, SEEK_CUR);
   if (off == static_cast<off_t>(-1))
     return ReportError("lseek for native FD returned error", errno);
   if (off != static_cast<off_t>(msg.size()))
     return ReportError("lseek for native FD offset mismatch", off);
 
   off = lseek(fd, 0, SEEK_SET);
   if (off == static_cast<off_t>(-1))
     return ReportError("lseek for native FD returned error", errno);
   if (off != 0)
     return ReportError("lseek for native FD offset mismatch", off);
 
   // Check read(2) for the native FD.
   std::string buf(msg.size(), '\0');
-  cnt = read(fd, &buf[0], msg.size());
+  cnt = read(fd, &buf[0], static_cast<unsigned>(msg.size()));
   if (cnt < 0)
     return ReportError("read for native FD returned error", errno);
   if (cnt != static_cast<ssize_t>(msg.size()))
     return ReportError("read for native FD count mismatch", cnt);
   if (msg != buf)
     return ReportMismatch("read for native FD", buf, msg);
   PASS();
 }
 
 // Calling RequestOSFileHandle with the FileIO that is opened with
@@ skipping 194 matching lines @@
   // END mmap(2) test with a file handle opened in READONLY mode.
 
   if (close(fd) < 0)
     return ReportError("close for native FD returned error", errno);
 #endif  // !defined(PPAPI_OS_WIN)
 
   PASS();
 }
 
 std::string TestFileIO::MatchOpenExpectations(pp::FileSystem* file_system,
-                                              size_t open_flags,
-                                              size_t expectations) {
+                                              int32_t open_flags,
+                                              int32_t expectations) {
   std::string bad_argument =
       "TestFileIO::MatchOpenExpectations has invalid input arguments.";
   bool invalid_combination = !!(expectations & INVALID_FLAG_COMBINATION);
   if (invalid_combination) {
     if (expectations != INVALID_FLAG_COMBINATION)
       return bad_argument;
   } else {
     // Validate that one and only one of <some_expectation> and
     // DONT_<some_expectation> is specified.
     for (size_t remains = expectations, end = END_OF_OPEN_EXPECATION_PAIRS;
@@ skipping 63 matching lines @@
   if ((invalid_combination && callback.result() == PP_OK) ||
       (!invalid_combination &&
        ((callback.result() == PP_OK) != create_if_doesnt_exist))) {
     return ReportOpenError(open_flags);
   }
 
   return std::string();
 }
 
 // TODO(viettrungluu): Test Close(). crbug.com/69457