Switch to standard integer types in content/.

content/child/v8_value_converter_impl_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 <stddef.h>
+#include <stdint.h>
+
 #include <cmath>
 
+#include "base/macros.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/stl_util.h"
 #include "base/test/values_test_util.h"
 #include "base/values.h"
 #include "content/child/v8_value_converter_impl.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "v8/include/v8.h"
 
 namespace content {
 
@@ skipping 56 matching lines @@
         value->Get(v8::String::NewFromUtf8(isolate_, key.c_str()))
             .As<v8::String>();
     if (temp.IsEmpty()) {
       ADD_FAILURE();
       return std::string();
     }
     v8::String::Utf8Value utf8(temp);
     return std::string(*utf8, utf8.length());
   }
 
-  std::string GetString(base::ListValue* value, uint32 index) {
+  std::string GetString(base::ListValue* value, uint32_t index) {
     std::string temp;
     if (!value->GetString(static_cast<size_t>(index), &temp)) {
       ADD_FAILURE();
       return std::string();
     }
     return temp;
   }
 
-  std::string GetString(v8::Local<v8::Array> value, uint32 index) {
+  std::string GetString(v8::Local<v8::Array> value, uint32_t index) {
     v8::Local<v8::String> temp = value->Get(index).As<v8::String>();
     if (temp.IsEmpty()) {
       ADD_FAILURE();
       return std::string();
     }
     v8::String::Utf8Value utf8(temp);
     return std::string(*utf8, utf8.length());
   }
 
   bool IsNull(base::DictionaryValue* value, const std::string& key) {
     base::Value* child = NULL;
     if (!value->Get(key, &child)) {
       ADD_FAILURE();
       return false;
     }
     return child->GetType() == base::Value::TYPE_NULL;
   }
 
   bool IsNull(v8::Local<v8::Object> value, const std::string& key) {
     v8::Local<v8::Value> child =
         value->Get(v8::String::NewFromUtf8(isolate_, key.c_str()));
     if (child.IsEmpty()) {
       ADD_FAILURE();
       return false;
     }
     return child->IsNull();
   }
 
-  bool IsNull(base::ListValue* value, uint32 index) {
+  bool IsNull(base::ListValue* value, uint32_t index) {
     base::Value* child = NULL;
     if (!value->Get(static_cast<size_t>(index), &child)) {
       ADD_FAILURE();
       return false;
     }
     return child->GetType() == base::Value::TYPE_NULL;
   }
 
-  bool IsNull(v8::Local<v8::Array> value, uint32 index) {
+  bool IsNull(v8::Local<v8::Array> value, uint32_t index) {
     v8::Local<v8::Value> child = value->Get(index);
     if (child.IsEmpty()) {
       ADD_FAILURE();
       return false;
     }
     return child->IsNull();
   }
 
   void TestWeirdType(const V8ValueConverterImpl& converter,
                      v8::Local<v8::Value> val,
@@ skipping 725 matching lines @@
   EXPECT_TRUE(
       base::Value::Equals(reference_number_value.get(), number_value.get()));
 
   v8::Local<v8::Primitive> undefined(v8::Undefined(isolate_));
   scoped_ptr<base::Value> undefined_value(
       converter.FromV8Value(undefined, context));
   EXPECT_FALSE(undefined_value);
 }
 
 }  // namespace content