Enable size_t to int truncation warnings in PPAPI

ppapi/tests/test_udp_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_udp_socket.h"
 
 #include <vector>
 
 #include "ppapi/cpp/pass_ref.h"
 #include "ppapi/cpp/tcp_socket.h"
@@ skipping 138 matching lines @@
 }
 
 std::string TestUDPSocket::ReadSocket(pp::UDPSocket* socket,
                                       pp::NetAddress* address,
                                       size_t size,
                                       std::string* message) {
   std::vector<char> buffer(size);
   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()));
   *address = callback.output();
   message->assign(buffer.begin(), buffer.end());
   PASS();
 }
 
 std::string TestUDPSocket::PassMessage(pp::UDPSocket* target,
                                        pp::UDPSocket* source,
                                        const pp::NetAddress& target_address,
                                        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;
   ASSERT_SUBTEST_SUCCESS(ReadSocket(target, recvfrom_address, message.size(),
                                     &str));
 
   callback.WaitForResult(rv);
   CHECK_CALLBACK_BEHAVIOR(callback);
   ASSERT_FALSE(callback.result() < 0);
   ASSERT_EQ(message.size(), static_cast<size_t>(callback.result()));
@@ skipping 149 matching lines @@
 
   const size_t kParallelSends = 10;
   std::vector<TestCompletionCallback*> sendto_callbacks(kParallelSends);
   std::vector<int32_t> sendto_results(kParallelSends);
   size_t pending = 0;
   for (size_t i = 0; i < kParallelSends; i++) {
     sendto_callbacks[i] =
         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());
 
     if (sendto_results[i] == PP_ERROR_INPROGRESS) {
       // Run a pending send to completion to free a slot for the current send.
       ASSERT_GT(i, pending);
       sendto_callbacks[pending]->WaitForResult(sendto_results[pending]);
       CHECK_CALLBACK_BEHAVIOR(*sendto_callbacks[pending]);
       ASSERT_EQ(message.size(),
                 static_cast<size_t>(sendto_callbacks[pending]->result()));
       pending++;
       // 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]);
     }
   }
 
   // Finish all pending sends.
   for (size_t i = pending; i < kParallelSends; i++) {
     sendto_callbacks[i]->WaitForResult(sendto_results[i]);
     CHECK_CALLBACK_BEHAVIOR(*sendto_callbacks[i]);
     ASSERT_EQ(message.size(),
               static_cast<size_t>(sendto_callbacks[i]->result()));
   }
 
   for (size_t i = 0; i < kParallelSends; ++i)
     delete sendto_callbacks[i];
 
   for (size_t i = 0; i < kParallelSends; i++) {
     std::string str;
     ASSERT_SUBTEST_SUCCESS(
         ReadSocket(&server_socket, &recvfrom_address, message.size(), &str));
     ASSERT_EQ(message, str);
   }
 
   server_socket.Close();
   client_socket.Close();
 
   PASS();
 }