Enable size_t to int truncation warnings in PPAPI

ppapi/proxy/raw_var_data_unittest.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/proxy/raw_var_data.h"
 
 #include "base/logging.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/values.h"
@@ skipping 78 matching lines @@
 }
 
 TEST_F(RawVarDataTest, StringTest) {
   EXPECT_TRUE(WriteReadAndCompare(StringVar::StringToPPVar("")));
   EXPECT_TRUE(WriteReadAndCompare(StringVar::StringToPPVar("hello world!")));
 }
 
 TEST_F(RawVarDataTest, ArrayBufferTest) {
   std::string data = "hello world!";
   PP_Var var = PpapiGlobals::Get()->GetVarTracker()->MakeArrayBufferPPVar(
-      data.size(), data.data());
+      static_cast<uint32_t>(data.size()), data.data());
   EXPECT_TRUE(WriteReadAndCompare(var));
   var = PpapiGlobals::Get()->GetVarTracker()->MakeArrayBufferPPVar(
       0, static_cast<void*>(NULL));
   EXPECT_TRUE(WriteReadAndCompare(var));
   // TODO(raymes): add tests for shmem type array buffers.
 }
 
 TEST_F(RawVarDataTest, DictionaryArrayTest) {
   // Empty array.
   scoped_refptr<ArrayVar> array(new ArrayVar);
   ScopedPPVar release_array(ScopedPPVar::PassRef(), array->GetPPVar());
   EXPECT_TRUE(WriteReadAndCompare(array->GetPPVar()));
 
   size_t index = 0;
 
   // Array with primitives.
-  array->Set(index++, PP_MakeUndefined());
-  array->Set(index++, PP_MakeNull());
-  array->Set(index++, PP_MakeInt32(100));
-  array->Set(index++, PP_MakeBool(PP_FALSE));
-  array->Set(index++, PP_MakeDouble(0.123));
+  array->Set(static_cast<uint32_t>(index++), PP_MakeUndefined());
+  array->Set(static_cast<uint32_t>(index++), PP_MakeNull());
+  array->Set(static_cast<uint32_t>(index++), PP_MakeInt32(100));
+  array->Set(static_cast<uint32_t>(index++), PP_MakeBool(PP_FALSE));
+  array->Set(static_cast<uint32_t>(index++), PP_MakeDouble(0.123));
   EXPECT_TRUE(WriteReadAndCompare(array->GetPPVar()));
 
   // Array with 2 references to the same string.
   ScopedPPVar release_string(
       ScopedPPVar::PassRef(), StringVar::StringToPPVar("abc"));
-  array->Set(index++, release_string.get());
-  array->Set(index++, release_string.get());
+  array->Set(static_cast<uint32_t>(index++), release_string.get());
+  array->Set(static_cast<uint32_t>(index++), release_string.get());
   EXPECT_TRUE(WriteReadAndCompare(array->GetPPVar()));
 
   // Array with nested array that references the same string.
   scoped_refptr<ArrayVar> array2(new ArrayVar);
   ScopedPPVar release_array2(ScopedPPVar::PassRef(), array2->GetPPVar());
   array2->Set(0, release_string.get());
-  array->Set(index++, release_array2.get());
+  array->Set(static_cast<uint32_t>(index++), release_array2.get());
   EXPECT_TRUE(WriteReadAndCompare(array->GetPPVar()));
 
   // Empty dictionary.
   scoped_refptr<DictionaryVar> dictionary(new DictionaryVar);
   ScopedPPVar release_dictionary(ScopedPPVar::PassRef(),
                                  dictionary->GetPPVar());
   EXPECT_TRUE(WriteReadAndCompare(dictionary->GetPPVar()));
 
   // Dictionary with primitives.
   dictionary->SetWithStringKey("1", PP_MakeUndefined());
@@ skipping 10 matching lines @@
 
   // Dictionary with nested dictionary that references the same string.
   scoped_refptr<DictionaryVar> dictionary2(new DictionaryVar);
   ScopedPPVar release_dictionary2(ScopedPPVar::PassRef(),
                                   dictionary2->GetPPVar());
   dictionary2->SetWithStringKey("abc", release_string.get());
   dictionary->SetWithStringKey("8", release_dictionary2.get());
   EXPECT_TRUE(WriteReadAndCompare(dictionary->GetPPVar()));
 
   // Array with dictionary.
-  array->Set(index++, release_dictionary.get());
+  array->Set(static_cast<uint32_t>(index++), release_dictionary.get());
   EXPECT_TRUE(WriteReadAndCompare(array->GetPPVar()));
 
   // Array with dictionary with array.
   array2->Set(0, PP_MakeInt32(100));
   dictionary->SetWithStringKey("9", release_array2.get());
   EXPECT_TRUE(WriteReadAndCompare(array->GetPPVar()));
 
   // Array <-> dictionary cycle.
   dictionary->SetWithStringKey("10", release_array.get());
   PP_Var result;
   ASSERT_FALSE(WriteAndRead(release_dictionary.get(), &result));
   // Break the cycle.
   // TODO(raymes): We need some better machinery for releasing vars with
   // cycles. Remove the code below once we have that.
   dictionary->DeleteWithStringKey("10");
 
   // Array with self references.
-  array->Set(index, release_array.get());
+  array->Set(static_cast<uint32_t>(index), release_array.get());
   ASSERT_FALSE(WriteAndRead(release_array.get(), &result));
   // Break the self reference.
-  array->Set(index, PP_MakeUndefined());
+  array->Set(static_cast<uint32_t>(index), PP_MakeUndefined());
 }
 
 TEST_F(RawVarDataTest, ResourceTest) {
   // TODO(mgiuca): This test passes trivially, since GetVarTracker() returns a
   // TestVarTracker which returns a null PP_Var.
   ScopedPPVar resource(
       ScopedPPVar::PassRef(),
       PpapiGlobals::Get()->GetVarTracker()->MakeResourcePPVar(34));
   EXPECT_TRUE(WriteReadAndCompare(resource.get()));
 
   // TODO(mgiuca): Test a host resource with an IPC::Message. It is currently a
   // checkfail to deserialize such a resource.
 }
 
 }  // namespace proxy
 }  // namespace ppapi