Switch to standard integer types in ppapi/.

ppapi/proxy/raw_var_data.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 "ppapi/proxy/raw_var_data.h"
 
 #include <stack>
 
 #include "base/containers/hash_tables.h"
 #include "base/stl_util.h"
@@ skipping 10 matching lines @@
 using std::make_pair;
 
 namespace ppapi {
 namespace proxy {
 
 namespace {
 
 // When sending array buffers, if the size is over 256K, we use shared
 // memory instead of sending the data over IPC. Light testing suggests
 // shared memory is much faster for 256K and larger messages.
-static const uint32 kMinimumArrayBufferSizeForShmem = 256 * 1024;
-static uint32 g_minimum_array_buffer_size_for_shmem =
+static const uint32_t kMinimumArrayBufferSizeForShmem = 256 * 1024;
+static uint32_t g_minimum_array_buffer_size_for_shmem =
     kMinimumArrayBufferSizeForShmem;
 
 struct StackEntry {
   StackEntry(PP_Var v, size_t i) : var(v), data_index(i) {}
   PP_Var var;
   size_t data_index;
 };
 
 // For a given PP_Var, returns the RawVarData associated with it, or creates a
 // new one if there is no existing one. The data is appended to |data| if it
@@ skipping 164 matching lines @@
   for (size_t i = 0; i < data_.size(); ++i) {
     SerializedHandle* handle = data_[i]->GetHandle();
     if (handle)
       result.push_back(handle);
   }
   return result;
 }
 
 // static
 void RawVarDataGraph::SetMinimumArrayBufferSizeForShmemForTest(
-    uint32 threshold) {
+    uint32_t threshold) {
   if (threshold == 0)
     g_minimum_array_buffer_size_for_shmem = kMinimumArrayBufferSizeForShmem;
   else
     g_minimum_array_buffer_size_for_shmem = threshold;
 }
 
 // RawVarData ------------------------------------------------------------------
 
 // static
 RawVarData* RawVarData::Create(PP_VarType type) {
@@ skipping 209 matching lines @@
   }
   initialized_ = true;
   return true;
 }
 
 PP_Var ArrayBufferRawVarData::CreatePPVar(PP_Instance instance) {
   PP_Var result = PP_MakeUndefined();
   switch (type_) {
     case ARRAY_BUFFER_SHMEM_HOST: {
       base::SharedMemoryHandle host_handle;
-      uint32 size_in_bytes;
+      uint32_t size_in_bytes;
       bool ok = PpapiGlobals::Get()->GetVarTracker()->
           StopTrackingSharedMemoryHandle(host_shm_handle_id_,
                                          instance,
                                          &host_handle,
                                          &size_in_bytes);
       if (ok) {
         result = PpapiGlobals::Get()->GetVarTracker()->MakeArrayBufferPPVar(
             size_in_bytes, host_handle);
       } else {
         LOG(ERROR) << "Couldn't find array buffer id: " << host_shm_handle_id_;
         return PP_MakeUndefined();
       }
       break;
     }
     case ARRAY_BUFFER_SHMEM_PLUGIN: {
       result = PpapiGlobals::Get()->GetVarTracker()->MakeArrayBufferPPVar(
           plugin_shm_handle_.size(),
           plugin_shm_handle_.shmem());
       break;
     }
     case ARRAY_BUFFER_NO_SHMEM: {
       result = PpapiGlobals::Get()->GetVarTracker()->MakeArrayBufferPPVar(
-          static_cast<uint32>(data_.size()), data_.data());
+          static_cast<uint32_t>(data_.size()), data_.data());
       break;
     }
     default:
       NOTREACHED();
       return PP_MakeUndefined();
   }
   DCHECK(result.type == PP_VARTYPE_ARRAY_BUFFER);
   return result;
 }
 
@@ skipping 260 matching lines @@
     if (!IPC::ReadParam(m, iter, creation_message_.get()))
       return false;
   } else {
     creation_message_.reset();
   }
   return true;
 }
 
 }  // namespace proxy
 }  // namespace ppapi