Switch to standard integer types in content/renderer/.

content/renderer/pepper/v8_var_converter_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 "content/renderer/pepper/v8_var_converter.h"
 
+#include <stddef.h>
+#include <stdint.h>
+
 #include <cmath>
 
 #include "base/logging.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/values.h"
 #include "content/renderer/pepper/resource_converter.h"
@@ skipping 89 matching lines @@
     v8::String::Utf8Value utf8(val);
     return std::string(*utf8, utf8.length()) == string_var->value();
   } else if (val->IsArray()) {
     if (var.type != PP_VARTYPE_ARRAY)
       return false;
     ArrayVar* array_var = ArrayVar::FromPPVar(var);
     DCHECK(array_var);
     v8::Local<v8::Array> v8_array = val.As<v8::Array>();
     if (v8_array->Length() != array_var->elements().size())
       return false;
-    for (uint32 i = 0; i < v8_array->Length(); ++i) {
+    for (uint32_t i = 0; i < v8_array->Length(); ++i) {
       v8::Local<v8::Value> child_v8 = v8_array->Get(i);
       if (!Equals(array_var->elements()[i].get(), child_v8, visited_ids))
         return false;
     }
     return true;
   } else if (val->IsObject()) {
     if (var.type == PP_VARTYPE_ARRAY_BUFFER) {
       // TODO(raymes): Implement this when we have tests for array buffers.
       NOTIMPLEMENTED();
       return false;
     } else {
       v8::Local<v8::Object> v8_object = val.As<v8::Object>();
       if (var.type != PP_VARTYPE_DICTIONARY)
         return false;
       DictionaryVar* dict_var = DictionaryVar::FromPPVar(var);
       DCHECK(dict_var);
       v8::Local<v8::Array> property_names(v8_object->GetOwnPropertyNames());
       if (property_names->Length() != dict_var->key_value_map().size())
         return false;
-      for (uint32 i = 0; i < property_names->Length(); ++i) {
+      for (uint32_t i = 0; i < property_names->Length(); ++i) {
         v8::Local<v8::Value> key(property_names->Get(i));
 
         if (!key->IsString() && !key->IsNumber())
           return false;
         v8::Local<v8::Value> child_v8 = v8_object->Get(key);
 
         v8::String::Utf8Value name_utf8(key);
         ScopedPPVar release_key(ScopedPPVar::PassRef(),
                                 StringVar::StringToPPVar(std::string(
                                     *name_utf8, name_utf8.length())));
@@ skipping 290 matching lines @@
     expected->SetWithStringKey("null", quux.get());
     ScopedPPVar oops(ScopedPPVar::PassRef(), StringVar::StringToPPVar("oops"));
     expected->SetWithStringKey("undefined", oops.get());
     ScopedPPVar release_expected(ScopedPPVar::PassRef(), expected->GetPPVar());
 
     ASSERT_TRUE(TestEqual(release_expected.get(), release_actual.get(), true));
   }
 }
 
 }  // namespace content