Switch to standard integer types in chrome/browser/, part 3 of 4.

chrome/browser/safe_browsing/protocol_parser.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.
 //
 // Parse the data returned from the SafeBrowsing v2.1 protocol response.
 
 // TODOv3(shess): Review these changes carefully.
 
+#include <stdint.h>
 #include <stdlib.h>
 
 #include "base/format_macros.h"
 #include "base/logging.h"
+#include "base/macros.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_split.h"
 #include "base/strings/stringprintf.h"
 #include "base/sys_byteorder.h"
 #include "base/time/time.h"
 #include "build/build_config.h"
 #include "chrome/browser/safe_browsing/protocol_parser.h"
 #include "chrome/browser/safe_browsing/safe_browsing_util.h"
 
 namespace safe_browsing {
@@ skipping 42 matching lines @@
   // Copy data out of the buffer.
   bool GetData(void* ptr, size_t l) {
     const void* buf_ptr;
     if (!RefData(&buf_ptr, l))
       return false;
 
     memcpy(ptr, buf_ptr, l);
     return true;
   }
 
-  // Read a 32-bit integer in network byte order into a local uint32.
-  bool GetNet32(uint32* i) {
+  // Read a 32-bit integer in network byte order into a local uint32_t.
+  bool GetNet32(uint32_t* i) {
     if (!GetData(i, sizeof(*i)))
       return false;
 
     *i = base::NetToHost32(*i);
     return true;
   }
 
   // Returns false if there is no data, otherwise fills |*line| with a reference
   // to the next line of data in the buffer.
   bool GetLine(base::StringPiece* line) {
@@ skipping 260 matching lines @@
 
 // BODY      = (UINT32 CHUNKDATA)+
 // UINT32    = Unsigned 32-bit integer in network byte order
 // CHUNKDATA = Encoded ChunkData protocol message
 bool ParseChunk(const char* data,
                 size_t length,
                 std::vector<scoped_ptr<SBChunkData>>* chunks) {
   BufferReader reader(data, length);
 
   while (!reader.empty()) {
-    uint32 l = 0;
+    uint32_t l = 0;
     if (!reader.GetNet32(&l) || l == 0 || l > reader.length())
       return false;
 
     const void* p = NULL;
     if (!reader.RefData(&p, l))
       return false;
 
     scoped_ptr<SBChunkData> chunk(new SBChunkData());
     if (!chunk->ParseFrom(reinterpret_cast<const unsigned char*>(p), l))
       return false;
@@ skipping 20 matching lines @@
   if (!list.adds.empty() && !list.subs.empty())
     formatted_results.append(":");
   if (!list.subs.empty())
     formatted_results.append("s:").append(list.subs);
   formatted_results.append("\n");
 
   return formatted_results;
 }
 
 }  // namespace safe_browsing