Enable size_t to int truncation warnings in PPAPI

ppapi/tests/test_tcp_socket.cc

 // Copyright 2013 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_socket.h"
 
 #include <vector>
 
 #include "ppapi/cpp/message_loop.h"
 #include "ppapi/cpp/tcp_socket.h"
@@ skipping 267 matching lines @@
     ASSERT_FALSE(accepted_sockets[i]->is_null());
   }
 
   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(WriteToSocket(client_sockets[i],
                                          std::string(1, byte)));
   }
 
   bool byte_received[kBacklog] = {};
   for (size_t i = 0; i < kBacklog; ++i) {
     char byte;
     ASSERT_SUBTEST_SUCCESS(ReadFromSocket(
         accepted_sockets[i], &byte, sizeof(byte)));
     const size_t index = byte - 'a';
@@ skipping 78 matching lines @@
   }
   PASS();
 }
 
 std::string TestTCPSocket::ReadFromSocket(pp::TCPSocket* 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_GT(callback.result(), 0);
     buffer += callback.result();
     num_bytes -= callback.result();
   }
   ASSERT_EQ(0u, num_bytes);
   PASS();
 }
 
 std::string TestTCPSocket::WriteToSocket(pp::TCPSocket* socket,
                                          const std::string& s) {
   const char* buffer = s.data();
   size_t written = 0;
   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();
   }
   ASSERT_EQ(written, s.size());
   PASS();
 }
 
 std::string TestTCPSocket::WriteToSocket_1_0(
     PP_Resource socket,
     const std::string& s) {
   const char* buffer = s.data();
   size_t written = 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);
     written += cb.result();
   }
   ASSERT_EQ(written, s.size());
   PASS();
 }
 
 std::string TestTCPSocket::GetAddressToBind(pp::NetAddress* address) {
@@ skipping 19 matching lines @@
   CHECK_CALLBACK_BEHAVIOR(callback);
   ASSERT_EQ(PP_OK, callback.result());
 
   callback.WaitForResult(
       socket->Listen(backlog, callback.GetCallback()));
   CHECK_CALLBACK_BEHAVIOR(callback);
   ASSERT_EQ(PP_OK, callback.result());
 
   PASS();
 }