Enable size_t to int truncation warnings in PPAPI

ppapi/tests/test_tcp_server_socket_private.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_tcp_server_socket_private.h"
 
 #include <cstdio>
 #include <vector>
 
 #include "ppapi/cpp/pass_ref.h"
@@ skipping 59 matching lines @@
   socket.Disconnect();
   PASS();
 }
 
 std::string TestTCPServerSocketPrivate::SyncRead(TCPSocketPrivate* socket,
                                                  char* buffer,
                                                  size_t num_bytes) {
   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();
     num_bytes -= callback.result();
   }
   PASS();
 }
 
 std::string TestTCPServerSocketPrivate::SyncWrite(TCPSocketPrivate* socket,
                                                   const char* buffer,
                                                   size_t num_bytes) {
   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();
     num_bytes -= callback.result();
   }
   PASS();
 }
 
 std::string TestTCPServerSocketPrivate::SyncConnect(
     TCPSocketPrivate* socket,
@@ skipping 123 matching lines @@
     accepted_sockets[i] = new TCPSocketPrivate(pp::PassRef(), resources[i]);
   }
 
   for (size_t i = 0; i < kBacklog; ++i) {
     connect_callbacks[i]->WaitForResult(connect_rv[i]);
     CHECK_CALLBACK_BEHAVIOR(*connect_callbacks[i]);
     ASSERT_EQ(PP_OK, connect_callbacks[i]->result());
   }
 
   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)));
   }
 
   bool byte_received[kBacklog] = {};
   for (size_t i = 0; i < kBacklog; ++i) {
     char byte;
     ASSERT_SUBTEST_SUCCESS(SyncRead(accepted_sockets[i], &byte, sizeof(byte)));
     const size_t index = byte - 'a';
     ASSERT_FALSE(byte_received[index]);
     byte_received[index] = true;
   }
 
   for (size_t i = 0; i < kBacklog; ++i) {
     client_sockets[i]->Disconnect();
     delete client_sockets[i];
     delete connect_callbacks[i];
     accepted_sockets[i]->Disconnect();
     delete accepted_sockets[i];
   }
 
   server_socket.StopListening();
   PASS();
 }