Remove kuint32max.

sandbox/win/src/crosscall_server.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 SANDBOX_SRC_CROSSCALL_SERVER_H_
 #define SANDBOX_SRC_CROSSCALL_SERVER_H_
 
 #include <string>
 #include <vector>
-#include "base/basictypes.h"
+
 #include "base/callback.h"
+#include "base/macros.h"
 #include "base/strings/string16.h"
 #include "sandbox/win/src/crosscall_params.h"
 
 // This is the IPC server interface for CrossCall: The  IPC for the Sandbox
 // On the server, CrossCall needs two things:
 // 1) threads: Or better said, someone to provide them, that is what the
 //             ThreadProvider interface is defined for. These thread(s) are
 //             the ones that will actually execute the  IPC data retrieval.
 //
 // 2) a dispatcher: This interface represents the way to route and process
@@ skipping 65 matching lines @@
 // Models the server-side of the original input parameters.
 // Provides IPC buffer validation and it is capable of reading the parameters
 // out of the IPC buffer.
 class CrossCallParamsEx : public CrossCallParams {
  public:
   // Factory constructor. Pass an IPCbuffer (and buffer size) that contains a
   // pending IPCcall. This constructor will:
   // 1) validate the IPC buffer. returns NULL is the IPCbuffer is malformed.
   // 2) make a copy of the IPCbuffer (parameter capture)
   static CrossCallParamsEx* CreateFromBuffer(void* buffer_base,
-                                             uint32 buffer_size,
-                                             uint32* output_size);
+                                             uint32_t buffer_size,
+                                             uint32_t* output_size);
 
   // Provides IPCinput parameter raw access:
   // index : the parameter to read; 0 is the first parameter
   // returns NULL if the parameter is non-existent. If it exists it also
   // returns the size in *size
-  void* GetRawParameter(uint32 index, uint32* size, ArgType* type);
+  void* GetRawParameter(uint32_t index, uint32_t* size, ArgType* type);
 
   // Gets a parameter that is four bytes in size.
   // Returns false if the parameter does not exist or is not 32 bits wide.
-  bool GetParameter32(uint32 index, uint32* param);
+  bool GetParameter32(uint32_t index, uint32_t* param);
 
   // Gets a parameter that is void pointer in size.
   // Returns false if the parameter does not exist or is not void pointer sized.
-  bool GetParameterVoidPtr(uint32 index, void** param);
+  bool GetParameterVoidPtr(uint32_t index, void** param);
 
   // Gets a parameter that is a string. Returns false if the parameter does not
   // exist.
-  bool GetParameterStr(uint32 index, base::string16* string);
+  bool GetParameterStr(uint32_t index, base::string16* string);
 
   // Gets a parameter that is an in/out buffer. Returns false is the parameter
   // does not exist or if the size of the actual parameter is not equal to the
   // expected size.
-  bool GetParameterPtr(uint32 index, uint32 expected_size, void** pointer);
+  bool GetParameterPtr(uint32_t index, uint32_t expected_size, void** pointer);
 
   // Frees the memory associated with the IPC parameters.
   static void operator delete(void* raw_memory) throw();
 
  private:
   // Only the factory method CreateFromBuffer can construct these objects.
   CrossCallParamsEx();
 
   ParamInfo param_info_[1];
   DISALLOW_COPY_AND_ASSIGN(CrossCallParamsEx);
@@ skipping 84 matching lines @@
     CallbackGeneric callback;
   };
 
   // List of IPC Calls supported by the class.
   std::vector<IPCCall> ipc_calls_;
 };
 
 }  // namespace sandbox
 
 #endif  // SANDBOX_SRC_CROSSCALL_SERVER_H_