Switch to standard integer types in content/renderer/.

content/renderer/pepper/v8_var_converter.cc

 // Copyright (c) 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 "content/renderer/pepper/v8_var_converter.h"
 
+#include <stddef.h>
+#include <stdint.h>
+
 #include <map>
 #include <stack>
 #include <string>
 
 #include "base/bind.h"
 #include "base/containers/hash_tables.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "content/public/renderer/renderer_ppapi_host.h"
@@ skipping 353 matching lines @@
                                 &child_v8,
                                 &did_create,
                                 &visited_ids,
                                 &parent_ids,
                                 resource_converter_.get())) {
           return false;
         }
         if (did_create && CanHaveChildren(child_var))
           stack.push(child_var);
         v8::TryCatch try_catch(isolate);
-        v8_array->Set(static_cast<uint32>(i), child_v8);
+        v8_array->Set(static_cast<uint32_t>(i), child_v8);
         if (try_catch.HasCaught()) {
           LOG(ERROR) << "Setter for index " << i << " threw an exception.";
           return false;
         }
       }
     } else if (current_var.type == PP_VARTYPE_DICTIONARY) {
       parent_ids.insert(current_var.value.as_id);
       DictionaryVar* dict_var = DictionaryVar::FromPPVar(current_var);
       if (!dict_var) {
         NOTREACHED();
@@ skipping 118 matching lines @@
       DCHECK(current_v8->IsArray());
       v8::Local<v8::Array> v8_array = current_v8.As<v8::Array>();
       parent_handles.insert(HashedHandle(v8_array));
 
       ArrayVar* array_var = ArrayVar::FromPPVar(current_var);
       if (!array_var) {
         NOTREACHED();
         return false;
       }
 
-      for (uint32 i = 0; i < v8_array->Length(); ++i) {
+      for (uint32_t i = 0; i < v8_array->Length(); ++i) {
         v8::TryCatch try_catch(context->GetIsolate());
         v8::Local<v8::Value> child_v8 = v8_array->Get(i);
         if (try_catch.HasCaught())
           return false;
 
         if (!v8_array->HasRealIndexedProperty(i))
           continue;
 
         PP_Var child_var;
         if (!GetOrCreateVar(child_v8,
@@ skipping 17 matching lines @@
       v8::Local<v8::Object> v8_object = current_v8.As<v8::Object>();
       parent_handles.insert(HashedHandle(v8_object));
 
       DictionaryVar* dict_var = DictionaryVar::FromPPVar(current_var);
       if (!dict_var) {
         NOTREACHED();
         return false;
       }
 
       v8::Local<v8::Array> property_names(v8_object->GetOwnPropertyNames());
-      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));
 
         // Extend this test to cover more types as necessary and if sensible.
         if (!key->IsString() && !key->IsNumber()) {
           NOTREACHED() << "Key \"" << *v8::String::Utf8Value(key)
                        << "\" "
                           "is neither a string nor a number";
           return false;
         }
 
@@ skipping 29 matching lines @@
             std::string(*name_utf8, name_utf8.length()), child_var);
         DCHECK(success);
       }
     }
   }
   *result_var = root;
   return true;
 }
 
 }  // namespace content