Switch to standard integer types in ppapi/.

ppapi/shared_impl/var.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/shared_impl/var.h"
 
+#include <stddef.h>
+
 #include <limits>
 
 #include "base/logging.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "ppapi/c/pp_var.h"
 #include "ppapi/shared_impl/ppapi_globals.h"
 #include "ppapi/shared_impl/resource_var.h"
 #include "ppapi/shared_impl/var_tracker.h"
@@ skipping 66 matching lines @@
 
 ProxyObjectVar* Var::AsProxyObjectVar() { return NULL; }
 
 ArrayVar* Var::AsArrayVar() { return NULL; }
 
 DictionaryVar* Var::AsDictionaryVar() { return NULL; }
 
 ResourceVar* Var::AsResourceVar() { return NULL; }
 
 PP_Var Var::GetPPVar() {
-  int32 id = GetOrCreateVarID();
+  int32_t id = GetOrCreateVarID();
   if (!id)
     return PP_MakeNull();
 
   PP_Var result;
   result.type = GetType();
   result.padding = 0;
   result.value.as_id = id;
   return result;
 }
 
-int32 Var::GetExistingVarID() const { return var_id_; }
+int32_t Var::GetExistingVarID() const {
+  return var_id_;
+}
 
 Var::Var() : var_id_(0) {}
 
 Var::~Var() {}
 
-int32 Var::GetOrCreateVarID() {
+int32_t Var::GetOrCreateVarID() {
   VarTracker* tracker = PpapiGlobals::Get()->GetVarTracker();
   if (var_id_) {
     if (!tracker->AddRefVar(var_id_))
       return 0;
   } else {
     var_id_ = tracker->AddVar(this);
     if (!var_id_)
       return 0;
   }
   return var_id_;
 }
 
-void Var::AssignVarID(int32 id) {
+void Var::AssignVarID(int32_t id) {
   DCHECK(!var_id_);  // Must not have already been generated.
   var_id_ = id;
 }
 
 // StringVar -------------------------------------------------------------------
 
 StringVar::StringVar() {}
 
 StringVar::StringVar(const std::string& str) : value_(str) {}
 
-StringVar::StringVar(const char* str, uint32 len) : value_(str, len) {}
+StringVar::StringVar(const char* str, uint32_t len) : value_(str, len) {}
 
 StringVar::~StringVar() {}
 
 StringVar* StringVar::AsStringVar() { return this; }
 
 PP_VarType StringVar::GetType() const { return PP_VARTYPE_STRING; }
 
 // static
 PP_Var StringVar::StringToPPVar(const std::string& var) {
-  return StringToPPVar(var.c_str(), static_cast<uint32>(var.size()));
+  return StringToPPVar(var.c_str(), static_cast<uint32_t>(var.size()));
 }
 
 // static
-PP_Var StringVar::StringToPPVar(const char* data, uint32 len) {
+PP_Var StringVar::StringToPPVar(const char* data, uint32_t len) {
   scoped_refptr<StringVar> str(new StringVar(data, len));
   if (!str.get() || !base::IsStringUTF8(str->value()))
     return PP_MakeNull();
   return str->GetPPVar();
 }
 
 // static
 StringVar* StringVar::FromPPVar(PP_Var var) {
   if (var.type != PP_VARTYPE_STRING)
     return NULL;
@@ skipping 26 matching lines @@
   if (var.type != PP_VARTYPE_ARRAY_BUFFER)
     return NULL;
   scoped_refptr<Var> var_object(
       PpapiGlobals::Get()->GetVarTracker()->GetVar(var));
   if (!var_object.get())
     return NULL;
   return var_object->AsArrayBufferVar();
 }
 
 }  // namespace ppapi