Switch to standard integer types in ppapi/.

ppapi/proxy/plugin_dispatcher.h

 // 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.
 
 #ifndef PPAPI_PROXY_PLUGIN_DISPATCHER_H_
 #define PPAPI_PROXY_PLUGIN_DISPATCHER_H_
 
+#include <stdint.h>
+
 #include <set>
 #include <string>
 
-#include "base/basictypes.h"
 #include "base/containers/hash_tables.h"
 #include "base/containers/scoped_ptr_hash_map.h"
+#include "base/macros.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/weak_ptr.h"
 #include "base/process/process.h"
 #include "build/build_config.h"
 #include "ipc/ipc_sync_channel.h"
 #include "ppapi/c/pp_instance.h"
 #include "ppapi/c/pp_rect.h"
 #include "ppapi/c/ppb_console.h"
 #include "ppapi/proxy/dispatcher.h"
 #include "ppapi/proxy/message_handler.h"
@@ skipping 43 matching lines @@
   // The message handler which should handle JavaScript->Plugin messages, if
   // one has been registered, otherwise NULL.
   scoped_ptr<MessageHandler> message_handler;
 
   // Flush info for PpapiCommandBufferProxy::OrderingBarrier().
   struct FlushInfo {
     FlushInfo();
     ~FlushInfo();
     bool flush_pending;
     HostResource resource;
-    int32 put_offset;
+    int32_t put_offset;
   };
   FlushInfo flush_info_;
 };
 
 class PPAPI_PROXY_EXPORT PluginDispatcher
     : public Dispatcher,
       public base::SupportsWeakPtr<PluginDispatcher> {
  public:
   class PPAPI_PROXY_EXPORT PluginDelegate : public ProxyChannel::Delegate {
    public:
     // Returns the set used for globally uniquifying PP_Instances. This same
     // set must be returned for all channels.
     //
     // DEREFERENCE ONLY ON THE I/O THREAD.
     virtual std::set<PP_Instance>* GetGloballySeenInstanceIDSet() = 0;
 
     // Registers the plugin dispatcher and returns an ID.
     // Plugin dispatcher IDs will be used to dispatch messages from the browser.
     // Each call to Register() has to be matched with a call to Unregister().
-    virtual uint32 Register(PluginDispatcher* plugin_dispatcher) = 0;
-    virtual void Unregister(uint32 plugin_dispatcher_id) = 0;
+    virtual uint32_t Register(PluginDispatcher* plugin_dispatcher) = 0;
+    virtual void Unregister(uint32_t plugin_dispatcher_id) = 0;
   };
 
   // Constructor for the plugin side. The init and shutdown functions will be
   // will be automatically called when requested by the renderer side. The
   // module ID will be set upon receipt of the InitializeModule message.
   //
   // Note about permissions: On the plugin side, the dispatcher and the plugin
   // run in the same address space (including in nacl). This means that the
   // permissions here are subject to malicious modification and bypass, and
   // an exploited or malicious plugin could send any IPC messages and just
@@ skipping 65 matching lines @@
   InstanceData* GetInstanceData(PP_Instance instance);
 
   // Returns the corresponding API. These are APIs not associated with a
   // resource. Guaranteed non-NULL.
   thunk::PPB_Instance_API* GetInstanceAPI();
   thunk::ResourceCreationAPI* GetResourceCreationAPI();
 
   // Returns the Preferences.
   const Preferences& preferences() const { return preferences_; }
 
-  uint32 plugin_dispatcher_id() const { return plugin_dispatcher_id_; }
+  uint32_t plugin_dispatcher_id() const { return plugin_dispatcher_id_; }
   bool incognito() const { return incognito_; }
 
  private:
   friend class PluginDispatcherTest;
 
   // Notifies all live instances that they're now closed. This is used when
   // a renderer crashes or some other error is received.
   void ForceFreeAllInstances();
 
   // IPC message handlers.
@@ skipping 13 matching lines @@
 
   typedef base::ScopedPtrHashMap<PP_Instance, scoped_ptr<InstanceData>>
       InstanceDataMap;
   InstanceDataMap instance_map_;
 
   // The preferences sent from the host. We only want to set this once, which
   // is what the received_preferences_ indicates. See OnMsgSetPreferences.
   bool received_preferences_;
   Preferences preferences_;
 
-  uint32 plugin_dispatcher_id_;
+  uint32_t plugin_dispatcher_id_;
 
   // Set to true when the instances associated with this dispatcher are
   // incognito mode.
   bool incognito_;
 
   // A filter for sending messages from threads other than the main thread.
   scoped_refptr<IPC::SyncMessageFilter> sync_filter_;
 
   DISALLOW_COPY_AND_ASSIGN(PluginDispatcher);
 };
 
 }  // namespace proxy
 }  // namespace ppapi
 
 #endif  // PPAPI_PROXY_PLUGIN_DISPATCHER_H_