Enable size_t to int truncation warnings in PPAPI

Also removed a few extra "-Wpedantic" warnings in ppapi_cpp. I don't see a good justification why this should be different than the rest of the project.

Fix GN error in media.

NOPRESUBMIT=true

Review URL: https://codereview.chromium.org/915403003

Cr-Commit-Position: refs/heads/master@{#316289}

18 files changed, 99 insertions, 63 deletions

diff --git a/ppapi/tests/test_file_io.cc b/ppapi/tests/test_file_io.cc
index 5b26804..8783905 100644
--- a/ppapi/tests/test_file_io.cc
+++ b/ppapi/tests/test_file_io.cc
@@ -150,7 +150,7 @@ int32_t WriteEntireBuffer(PP_Instance instance,
   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,
@@ -781,7 +781,7 @@ std::string TestFileIO::TestParallelReads() {
 
   // 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;
@@ -865,12 +865,12 @@ std::string TestFileIO::TestParallelWrites() {
   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;
@@ -879,7 +879,8 @@ std::string TestFileIO::TestParallelWrites() {
       // 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);
     }
@@ -887,7 +888,8 @@ std::string TestFileIO::TestParallelWrites() {
       // 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);
     }
@@ -951,7 +953,8 @@ std::string TestFileIO::TestNotAllowMixedReadWrite() {
   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);
 
@@ -966,7 +969,8 @@ std::string TestFileIO::TestNotAllowMixedReadWrite() {
   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;
@@ -977,7 +981,8 @@ std::string TestFileIO::TestNotAllowMixedReadWrite() {
   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,
@@ -988,7 +993,8 @@ std::string TestFileIO::TestNotAllowMixedReadWrite() {
   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()));
@@ -1038,7 +1044,7 @@ std::string TestFileIO::TestRequestOSFileHandle() {
 
   // 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()))
@@ -1059,7 +1065,7 @@ std::string TestFileIO::TestRequestOSFileHandle() {
 
   // 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()))
@@ -1274,8 +1280,8 @@ std::string TestFileIO::TestMmap() {
 }
 
 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);
diff --git a/ppapi/tests/test_file_io.h b/ppapi/tests/test_file_io.h
index 3cc0095..e01abcf 100644
--- a/ppapi/tests/test_file_io.h
+++ b/ppapi/tests/test_file_io.h
@@ -57,8 +57,8 @@ class TestFileIO : public TestCase {
   // 2) (DONT_)?CREATE_IF_DOESNT_EXIST | (DONT_)?OPEN_IF_EXISTS |
   //    (DONT_)?TRUNCATE_IF_EXISTS
   std::string MatchOpenExpectations(pp::FileSystem* file_system,
-                                    size_t open_flags,
-                                    size_t expectations);
+                                    int32_t open_flags,
+                                    int32_t expectations);
 };
 
 #endif  // PAPPI_TESTS_TEST_FILE_IO_H_
diff --git a/ppapi/tests/test_file_mapping.cc b/ppapi/tests/test_file_mapping.cc
index 4e879b5..ee10e18 100644
--- a/ppapi/tests/test_file_mapping.cc
+++ b/ppapi/tests/test_file_mapping.cc
@@ -55,7 +55,7 @@ int32_t WriteEntireBuffer(PP_Instance instance,
   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,
diff --git a/ppapi/tests/test_flash_clipboard.cc b/ppapi/tests/test_flash_clipboard.cc
index 505399d..e94cb7f 100644
--- a/ppapi/tests/test_flash_clipboard.cc
+++ b/ppapi/tests/test_flash_clipboard.cc
@@ -151,7 +151,7 @@ std::string TestFlashClipboard::TestReadWriteRTF() {
         "{\\rtf1\\ansi{\\fonttbl\\f0\\fswiss Helvetica;}\\f0\\pard\n"
         "This is some {\\b bold} text.\\par\n"
         "}";
-  pp::VarArrayBuffer array_buffer(rtf_string.size());
+  pp::VarArrayBuffer array_buffer(static_cast<uint32_t>(rtf_string.size()));
   char* bytes = static_cast<char*>(array_buffer.Map());
   std::copy(rtf_string.data(), rtf_string.data() + rtf_string.size(), bytes);
   std::vector<uint32_t> formats_vector(1, PP_FLASH_CLIPBOARD_FORMAT_RTF);
@@ -182,7 +182,7 @@ std::string TestFlashClipboard::TestReadWriteRTF() {
 
 std::string TestFlashClipboard::TestReadWriteCustomData() {
   std::string custom_data = "custom_data";
-  pp::VarArrayBuffer array_buffer(custom_data.size());
+  pp::VarArrayBuffer array_buffer(static_cast<uint32_t>(custom_data.size()));
   char* bytes = static_cast<char*>(array_buffer.Map());
   std::copy(custom_data.begin(), custom_data.end(), bytes);
   uint32_t format_id =
@@ -311,7 +311,7 @@ std::string TestFlashClipboard::TestGetSequenceNumber() {
 
   // Test the sequence number changes after writing some custom data.
   std::string custom_data = "custom_data";
-  pp::VarArrayBuffer array_buffer(custom_data.size());
+  pp::VarArrayBuffer array_buffer(static_cast<uint32_t>(custom_data.size()));
   char* bytes = static_cast<char*>(array_buffer.Map());
   std::copy(custom_data.begin(), custom_data.end(), bytes);
   uint32_t format_id =
diff --git a/ppapi/tests/test_flash_file.cc b/ppapi/tests/test_flash_file.cc
index 8e8db30..b252940 100644
--- a/ppapi/tests/test_flash_file.cc
+++ b/ppapi/tests/test_flash_file.cc
@@ -36,7 +36,8 @@ void CloseFileHandle(PP_FileHandle file_handle) {
 bool WriteFile(PP_FileHandle file_handle, const std::string& contents) {
 #if defined(PPAPI_OS_WIN)
   DWORD bytes_written = 0;
-  BOOL result = ::WriteFile(file_handle, contents.c_str(), contents.size(),
+  BOOL result = ::WriteFile(file_handle, contents.c_str(),
+                            static_cast<DWORD>(contents.size()),
                             &bytes_written, NULL);
   return result && bytes_written == static_cast<DWORD>(contents.size());
 #else
diff --git a/ppapi/tests/test_host_resolver.cc b/ppapi/tests/test_host_resolver.cc
index 2bb5012..27ecae1 100644
--- a/ppapi/tests/test_host_resolver.cc
+++ b/ppapi/tests/test_host_resolver.cc
@@ -85,10 +85,12 @@ std::string TestHostResolver::CheckHTTPResponse(pp::TCPSocket* socket,
                                                 const std::string& response) {
   int32_t rv = 0;
   ASSERT_SUBTEST_SUCCESS(
-      SyncWrite(socket, request.c_str(), request.size(), &rv));
+      SyncWrite(socket, request.c_str(), static_cast<int32_t>(request.size()),
+                &rv));
   std::vector<char> response_buffer(response.size());
   ASSERT_SUBTEST_SUCCESS(
-      SyncRead(socket, &response_buffer[0], response.size(), &rv));
+      SyncRead(socket, &response_buffer[0],
+               static_cast<int32_t>(response.size()), &rv));
   std::string actual_response(&response_buffer[0], rv);
   if (response != actual_response) {
     return "CheckHTTPResponse failed, expected: " + response +
@@ -121,7 +123,7 @@ std::string TestHostResolver::ParameterizedTestResolve(
 
   pp::NetAddress address;
   for (size_t i = 0; i < size; ++i) {
-    address = host_resolver.GetNetAddress(i);
+    address = host_resolver.GetNetAddress(static_cast<uint32_t>(i));
     ASSERT_NE(0, address.pp_resource());
 
     pp::TCPSocket socket(instance_);
@@ -132,7 +134,7 @@ std::string TestHostResolver::ParameterizedTestResolve(
     socket.Close();
   }
 
-  address = host_resolver.GetNetAddress(size);
+  address = host_resolver.GetNetAddress(static_cast<uint32_t>(size));
   ASSERT_EQ(0, address.pp_resource());
   pp::Var canonical_name = host_resolver.GetCanonicalName();
   ASSERT_TRUE(canonical_name.is_string());
diff --git a/ppapi/tests/test_host_resolver_private.cc b/ppapi/tests/test_host_resolver_private.cc
index 88429ed..e13cb99 100644
--- a/ppapi/tests/test_host_resolver_private.cc
+++ b/ppapi/tests/test_host_resolver_private.cc
@@ -100,10 +100,12 @@ std::string TestHostResolverPrivate::CheckHTTPResponse(
     const std::string& response) {
   int32_t rv = 0;
   ASSERT_SUBTEST_SUCCESS(
-      SyncWrite(socket, request.c_str(), request.size(), &rv));
+      SyncWrite(socket, request.c_str(), static_cast<int32_t>(request.size()),
+                &rv));
   std::vector<char> response_buffer(response.size());
   ASSERT_SUBTEST_SUCCESS(
-      SyncRead(socket, &response_buffer[0], response.size(), &rv));
+      SyncRead(socket, &response_buffer[0],
+               static_cast<int32_t>(response.size()), &rv));
   std::string actual_response(&response_buffer[0], rv);
   if (response != actual_response) {
     return "CheckHTTPResponse failed, expected: " + response +
@@ -144,7 +146,8 @@ std::string TestHostResolverPrivate::ParametrizedTestResolve(
 
   PP_NetAddress_Private address;
   for (size_t i = 0; i < size; ++i) {
-    ASSERT_TRUE(host_resolver.GetNetAddress(i, &address));
+    ASSERT_TRUE(host_resolver.GetNetAddress(
+        static_cast<uint32_t>(i), &address));
 
     pp::TCPSocketPrivate socket(instance_);
     ASSERT_SUBTEST_SUCCESS(SyncConnect(&socket, address));
@@ -154,7 +157,8 @@ std::string TestHostResolverPrivate::ParametrizedTestResolve(
     socket.Disconnect();
   }
 
-  ASSERT_FALSE(host_resolver.GetNetAddress(size, &address));
+  ASSERT_FALSE(host_resolver.GetNetAddress(
+      static_cast<uint32_t>(size), &address));
   pp::Var canonical_name = host_resolver.GetCanonicalName();
   ASSERT_TRUE(canonical_name.is_string());
   pp::TCPSocketPrivate socket(instance_);
diff --git a/ppapi/tests/test_memory.cc b/ppapi/tests/test_memory.cc
index 9073227..d4db7c2 100644
--- a/ppapi/tests/test_memory.cc
+++ b/ppapi/tests/test_memory.cc
@@ -30,7 +30,7 @@ void TestMemory::RunTests(const std::string& filter) {
 
 std::string TestMemory::TestMemAlloc() {
   char* buffer = static_cast<char*>(
-      memory_dev_interface_->MemAlloc(kTestBufferSize));
+      memory_dev_interface_->MemAlloc(static_cast<uint32_t>(kTestBufferSize)));
   // Touch a couple of locations.  Failure will crash the test.
   buffer[0] = '1';
   buffer[kTestBufferSize - 1] = '1';
diff --git a/ppapi/tests/test_network_monitor.cc b/ppapi/tests/test_network_monitor.cc
index 2d46f90..dcb712c 100644
--- a/ppapi/tests/test_network_monitor.cc
+++ b/ppapi/tests/test_network_monitor.cc
@@ -64,7 +64,7 @@ std::string TestNetworkMonitor::VerifyNetworkList(
   for (size_t iface = 0; iface < count; ++iface) {
     // Verify that the first interface has at least one address.
     std::vector<pp::NetAddress> addresses;
-    network_list.GetIpAddresses(iface, &addresses);
+    network_list.GetIpAddresses(static_cast<uint32_t>(iface), &addresses);
     ASSERT_TRUE(addresses.size() >= 1U);
     // Verify that the addresses are valid.
     for (size_t i = 0; i < addresses.size(); ++i) {
@@ -115,14 +115,17 @@ std::string TestNetworkMonitor::VerifyNetworkList(
     }
 
     // Verify that each interface has a unique name and a display name.
-    ASSERT_FALSE(network_list.GetName(iface).empty());
-    ASSERT_FALSE(network_list.GetDisplayName(iface).empty());
+    ASSERT_FALSE(network_list.GetName(static_cast<uint32_t>(iface)).empty());
+    ASSERT_FALSE(network_list.GetDisplayName(
+        static_cast<uint32_t>(iface)).empty());
 
-    PP_NetworkList_Type type = network_list.GetType(iface);
+    PP_NetworkList_Type type =
+        network_list.GetType(static_cast<uint32_t>(iface));
     ASSERT_TRUE(type >= PP_NETWORKLIST_TYPE_UNKNOWN);
     ASSERT_TRUE(type <= PP_NETWORKLIST_TYPE_CELLULAR);
 
-    PP_NetworkList_State state = network_list.GetState(iface);
+    PP_NetworkList_State state =
+        network_list.GetState(static_cast<uint32_t>(iface));
     ASSERT_TRUE(state >= PP_NETWORKLIST_STATE_DOWN);
     ASSERT_TRUE(state <= PP_NETWORKLIST_STATE_UP);
   }
diff --git a/ppapi/tests/test_post_message.cc b/ppapi/tests/test_post_message.cc
index 8e7be05..da560cf 100644
--- a/ppapi/tests/test_post_message.cc
+++ b/ppapi/tests/test_post_message.cc
@@ -294,7 +294,7 @@ int TestPostMessage::WaitForMessages() {
   // Now that the FINISHED_WAITING_MESSAGE has been echoed back to us, we know
   // that all pending messages have been slurped up. Return the number we
   // received (which may be zero).
-  return message_data_.size() - message_size_before;
+  return static_cast<int>(message_data_.size() - message_size_before);
 }
 
 std::string TestPostMessage::CheckMessageProperties(
@@ -594,7 +594,7 @@ std::string TestPostMessage::TestSendingResource() {
 
   std::string file_path("/");
   file_path += kTestFilename;
-  int content_length = strlen(kTestString);
+  int content_length = static_cast<int>(strlen(kTestString));
 
   // Create a file in the HTML5 temporary file system, in the Pepper plugin.
   TestCompletionCallback callback(instance_->pp_instance(), callback_type());
diff --git a/ppapi/tests/test_tcp_server_socket_private.cc b/ppapi/tests/test_tcp_server_socket_private.cc
index 2465d51..64b5402 100644
--- a/ppapi/tests/test_tcp_server_socket_private.cc
+++ b/ppapi/tests/test_tcp_server_socket_private.cc
@@ -77,7 +77,8 @@ std::string TestTCPServerSocketPrivate::SyncRead(TCPSocketPrivate* socket,
   while (num_bytes > 0) {
     TestCompletionCallback callback(instance_->pp_instance(), callback_type());
     callback.WaitForResult(
-        socket->Read(buffer, num_bytes, callback.GetCallback()));
+        socket->Read(buffer, static_cast<int32_t>(num_bytes),
+                     callback.GetCallback()));
     CHECK_CALLBACK_BEHAVIOR(callback);
     ASSERT_TRUE(callback.result() >= 0);
     buffer += callback.result();
@@ -92,7 +93,8 @@ std::string TestTCPServerSocketPrivate::SyncWrite(TCPSocketPrivate* socket,
   while (num_bytes > 0) {
     TestCompletionCallback callback(instance_->pp_instance(), callback_type());
     callback.WaitForResult(
-        socket->Write(buffer, num_bytes, callback.GetCallback()));
+        socket->Write(buffer, static_cast<int32_t>(num_bytes),
+                      callback.GetCallback()));
     CHECK_CALLBACK_BEHAVIOR(callback);
     ASSERT_TRUE(callback.result() >= 0);
     buffer += callback.result();
@@ -236,7 +238,7 @@ std::string TestTCPServerSocketPrivate::TestBacklog() {
   }
 
   for (size_t i = 0; i < kBacklog; ++i) {
-    const char byte = 'a' + i;
+    const char byte = static_cast<char>('a' + i);
     ASSERT_SUBTEST_SUCCESS(SyncWrite(client_sockets[i], &byte, sizeof(byte)));
   }
 
diff --git a/ppapi/tests/test_tcp_socket.cc b/ppapi/tests/test_tcp_socket.cc
index a3164de..877b469 100644
--- a/ppapi/tests/test_tcp_socket.cc
+++ b/ppapi/tests/test_tcp_socket.cc
@@ -285,7 +285,7 @@ std::string TestTCPSocket::TestBacklog() {
   }
 
   for (size_t i = 0; i < kBacklog; ++i) {
-    const char byte = 'a' + i;
+    const char byte = static_cast<char>('a' + i);
     ASSERT_SUBTEST_SUCCESS(WriteToSocket(client_sockets[i],
                                          std::string(1, byte)));
   }
@@ -384,7 +384,8 @@ std::string TestTCPSocket::ReadFromSocket(pp::TCPSocket* socket,
   while (num_bytes > 0) {
     TestCompletionCallback callback(instance_->pp_instance(), callback_type());
     callback.WaitForResult(
-        socket->Read(buffer, num_bytes, callback.GetCallback()));
+        socket->Read(buffer, static_cast<int32_t>(num_bytes),
+        callback.GetCallback()));
     CHECK_CALLBACK_BEHAVIOR(callback);
     ASSERT_GT(callback.result(), 0);
     buffer += callback.result();
@@ -401,7 +402,9 @@ std::string TestTCPSocket::WriteToSocket(pp::TCPSocket* socket,
   while (written < s.size()) {
     TestCompletionCallback cb(instance_->pp_instance(), callback_type());
     cb.WaitForResult(
-        socket->Write(buffer + written, s.size() - written, cb.GetCallback()));
+        socket->Write(buffer + written,
+                      static_cast<int32_t>(s.size() - written),
+                      cb.GetCallback()));
     CHECK_CALLBACK_BEHAVIOR(cb);
     ASSERT_GT(cb.result(), 0);
     written += cb.result();
@@ -418,7 +421,8 @@ std::string TestTCPSocket::WriteToSocket_1_0(
   while (written < s.size()) {
     TestCompletionCallback cb(instance_->pp_instance(), callback_type());
     cb.WaitForResult(socket_interface_1_0_->Write(
-        socket, buffer + written, s.size() - written,
+        socket, buffer + written,
+        static_cast<int32_t>(s.size() - written),
         cb.GetCallback().pp_completion_callback()));
     CHECK_CALLBACK_BEHAVIOR(cb);
     ASSERT_GT(cb.result(), 0);
diff --git a/ppapi/tests/test_tcp_socket_private.cc b/ppapi/tests/test_tcp_socket_private.cc
index d3efbe3..0d43a76 100644
--- a/ppapi/tests/test_tcp_socket_private.cc
+++ b/ppapi/tests/test_tcp_socket_private.cc
@@ -246,7 +246,8 @@ int32_t TestTCPSocketPrivate::WriteStringToSocket(pp::TCPSocketPrivate* socket,
   size_t written = 0;
   while (written < s.size()) {
     TestCompletionCallback cb(instance_->pp_instance(), callback_type());
-    int32_t rv = socket->Write(buffer + written, s.size() - written,
+    int32_t rv = socket->Write(buffer + written,
+                               static_cast<int32_t>(s.size() - written),
                                cb.GetCallback());
     if (callback_type() == PP_REQUIRED && rv != PP_OK_COMPLETIONPENDING)
       return PP_ERROR_FAILED;
diff --git a/ppapi/tests/test_udp_socket.cc b/ppapi/tests/test_udp_socket.cc
index 2b05682..89ea036 100644
--- a/ppapi/tests/test_udp_socket.cc
+++ b/ppapi/tests/test_udp_socket.cc
@@ -156,7 +156,8 @@ std::string TestUDPSocket::ReadSocket(pp::UDPSocket* socket,
   TestCompletionCallbackWithOutput<pp::NetAddress> callback(
       instance_->pp_instance(), callback_type());
   callback.WaitForResult(
-      socket->RecvFrom(&buffer[0], size, callback.GetCallback()));
+      socket->RecvFrom(&buffer[0], static_cast<int32_t>(size),
+      callback.GetCallback()));
   CHECK_CALLBACK_BEHAVIOR(callback);
   ASSERT_FALSE(callback.result() < 0);
   ASSERT_EQ(size, static_cast<size_t>(callback.result()));
@@ -171,7 +172,8 @@ std::string TestUDPSocket::PassMessage(pp::UDPSocket* target,
                                        const std::string& message,
                                        pp::NetAddress* recvfrom_address) {
   TestCompletionCallback callback(instance_->pp_instance(), callback_type());
-  int32_t rv = source->SendTo(message.c_str(), message.size(),
+  int32_t rv = source->SendTo(message.c_str(),
+                              static_cast<int32_t>(message.size()),
                               target_address,
                               callback.GetCallback());
   std::string str;
@@ -341,7 +343,7 @@ std::string TestUDPSocket::TestParallelSend() {
         new TestCompletionCallback(instance_->pp_instance(), callback_type());
     sendto_results[i] =
         client_socket.SendTo(message.c_str(),
-                             message.size(),
+                             static_cast<int32_t>(message.size()),
                              server_address,
                              sendto_callbacks[i]->GetCallback());
 
@@ -356,7 +358,7 @@ std::string TestUDPSocket::TestParallelSend() {
       // Try to send the message again.
       sendto_results[i] =
           client_socket.SendTo(message.c_str(),
-                               message.size(),
+                               static_cast<int32_t>(message.size()),
                                server_address,
                                sendto_callbacks[i]->GetCallback());
       ASSERT_NE(PP_ERROR_INPROGRESS, sendto_results[i]);
diff --git a/ppapi/tests/test_udp_socket_private.cc b/ppapi/tests/test_udp_socket_private.cc
index ae1b978..74dd8ba 100644
--- a/ppapi/tests/test_udp_socket_private.cc
+++ b/ppapi/tests/test_udp_socket_private.cc
@@ -138,7 +138,8 @@ std::string TestUDPSocketPrivate::ReadSocket(pp::UDPSocketPrivate* socket,
   std::vector<char> buffer(size);
   TestCompletionCallback callback(instance_->pp_instance(), callback_type());
   callback.WaitForResult(
-      socket->RecvFrom(&buffer[0], size, callback.GetCallback()));
+      socket->RecvFrom(&buffer[0], static_cast<int32_t>(size),
+      callback.GetCallback()));
   CHECK_CALLBACK_BEHAVIOR(callback);
   ASSERT_FALSE(callback.result() < 0);
   ASSERT_EQ(size, static_cast<size_t>(callback.result()));
@@ -151,7 +152,8 @@ std::string TestUDPSocketPrivate::PassMessage(pp::UDPSocketPrivate* target,
                                               PP_NetAddress_Private* address,
                                               const std::string& message) {
   TestCompletionCallback callback(instance_->pp_instance(), callback_type());
-  int32_t rv = source->SendTo(message.c_str(), message.size(), address,
+  int32_t rv = source->SendTo(message.c_str(),
+                              static_cast<int32_t>(message.size()), address,
                               callback.GetCallback());
   std::string str;
   ASSERT_SUBTEST_SUCCESS(ReadSocket(target, address, message.size(), &str));
diff --git a/ppapi/tests/test_url_loader.cc b/ppapi/tests/test_url_loader.cc
index 0d78efa..d3a210e 100644
--- a/ppapi/tests/test_url_loader.cc
+++ b/ppapi/tests/test_url_loader.cc
@@ -37,7 +37,7 @@ int32_t WriteEntireBuffer(PP_Instance instance,
   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,
@@ -343,7 +343,8 @@ std::string TestURLLoader::TestBasicPOST() {
   request.SetURL("/echo");
   request.SetMethod("POST");
   std::string postdata("postdata");
-  request.AppendDataToBody(postdata.data(), postdata.length());
+  request.AppendDataToBody(postdata.data(),
+                           static_cast<uint32_t>(postdata.length()));
   return LoadAndCompareBody(request, postdata);
 }
 
@@ -394,9 +395,11 @@ std::string TestURLLoader::TestCompoundBodyPOST() {
   request.SetURL("/echo");
   request.SetMethod("POST");
   std::string postdata1("post");
-  request.AppendDataToBody(postdata1.data(), postdata1.length());
+  request.AppendDataToBody(postdata1.data(),
+                           static_cast<uint32_t>(postdata1.length()));
   std::string postdata2("data");
-  request.AppendDataToBody(postdata2.data(), postdata2.length());
+  request.AppendDataToBody(postdata2.data(),
+                           static_cast<uint32_t>(postdata2.length()));
   return LoadAndCompareBody(request, postdata1 + postdata2);
 }
 
@@ -416,7 +419,8 @@ std::string TestURLLoader::TestBinaryDataPOST() {
       "\x00\x01\x02\x03\x04\x05postdata\xfa\xfb\xfc\xfd\xfe\xff";
   std::string postdata(postdata_chars,
                        sizeof(postdata_chars) / sizeof(postdata_chars[0]));
-  request.AppendDataToBody(postdata.data(), postdata.length());
+  request.AppendDataToBody(postdata.data(),
+                           static_cast<uint32_t>(postdata.length()));
   return LoadAndCompareBody(request, postdata);
 }
 
@@ -433,7 +437,8 @@ std::string TestURLLoader::TestFailsBogusContentLength() {
   request.SetMethod("POST");
   request.SetHeaders("Content-Length: 400");
   std::string postdata("postdata");
-  request.AppendDataToBody(postdata.data(), postdata.length());
+  request.AppendDataToBody(postdata.data(),
+                           static_cast<uint32_t>(postdata.length()));
 
   int32_t rv;
   rv = OpenUntrusted(request);
diff --git a/ppapi/tests/test_url_request.cc b/ppapi/tests/test_url_request.cc
index 22b0629..7c9847b 100644
--- a/ppapi/tests/test_url_request.cc
+++ b/ppapi/tests/test_url_request.cc
@@ -77,7 +77,7 @@ void TestURLRequest::RunTests(const std::string& filter) {
 }
 
 PP_Var TestURLRequest::PP_MakeString(const char* s) {
-  return ppb_var_interface_->VarFromUtf8(s, strlen(s));
+  return ppb_var_interface_->VarFromUtf8(s, static_cast<int32_t>(strlen(s)));
 }
 
 // Tests
@@ -357,7 +357,8 @@ std::string TestURLRequest::TestAppendDataToBody() {
 
   // Invalid resource should fail.
   ASSERT_EQ(PP_FALSE, ppb_url_request_interface_->AppendDataToBody(
-      kInvalidResource, postdata.data(), postdata.length()));
+      kInvalidResource, postdata.data(),
+      static_cast<uint32_t>(postdata.length())));
 
   // Append data and POST to echoing web server.
   ASSERT_EQ(PP_TRUE, ppb_url_request_interface_->SetProperty(
@@ -367,7 +368,8 @@ std::string TestURLRequest::TestAppendDataToBody() {
 
   // Append data to body and verify the body is what we expect.
   ASSERT_EQ(PP_TRUE, ppb_url_request_interface_->AppendDataToBody(
-      url_request, postdata.data(), postdata.length()));
+      url_request, postdata.data(),
+      static_cast<uint32_t>(postdata.length())));
   std::string error = LoadAndCompareBody(url_request, postdata);
 
   ppb_var_interface_->Release(post_string_var);
@@ -399,7 +401,7 @@ std::string TestURLRequest::TestAppendFileToBody() {
   std::string append_data = "hello\n";
   callback.WaitForResult(io.Write(0,
                                   append_data.c_str(),
-                                  append_data.size(),
+                                  static_cast<int32_t>(append_data.size()),
                                   callback.GetCallback()));
   CHECK_CALLBACK_BEHAVIOR(callback);
   ASSERT_EQ(static_cast<int32_t>(append_data.size()), callback.result());
diff --git a/ppapi/tests/test_websocket.cc b/ppapi/tests/test_websocket.cc
index e0a54aa..91046f2 100644
--- a/ppapi/tests/test_websocket.cc
+++ b/ppapi/tests/test_websocket.cc
@@ -259,11 +259,13 @@ std::string TestWebSocket::GetFullURL(const char* url) {
 }
 
 PP_Var TestWebSocket::CreateVarString(const std::string& string) {
-  return var_interface_->VarFromUtf8(string.c_str(), string.size());
+  return var_interface_->VarFromUtf8(string.c_str(),
+                                     static_cast<uint32_t>(string.size()));
 }
 
 PP_Var TestWebSocket::CreateVarBinary(const std::vector<uint8_t>& binary) {
-  PP_Var var = arraybuffer_interface_->Create(binary.size());
+  PP_Var var =
+      arraybuffer_interface_->Create(static_cast<uint32_t>(binary.size()));
   uint8_t* var_data = static_cast<uint8_t*>(arraybuffer_interface_->Map(var));
   std::copy(binary.begin(), binary.end(), var_data);
   return var;