Switch to standard integer types in courgette/.

courgette/third_party/bsdiff_create.cc

 /*
   bsdiff.c -- Binary patch generator.
 
   Copyright 2003 Colin Percival
 
   For the terms under which this work may be distributed, please see
   the adjoining file "LICENSE".
 
   ChangeLog:
   2005-05-05 - Use the modified header struct from bspatch.h; use 32-bit
@@ skipping 10 matching lines @@
                fragmented for these big arrays to be contiguous.
                  --Stephen Adams <sra@chromium.org>
   2015-08-03 - Extract qsufsort portion to a separate file.
                  --Samuel Huang <huangs@chromium.org>
   2015-08-12 - Interface change to qsufsort search().
                  --Samuel Huang <huangs@chromium.org>
 */
 
 #include "courgette/third_party/bsdiff.h"
 
+#include <stddef.h>
+#include <stdint.h>
 #include <stdlib.h>
 #include <algorithm>
 
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/strings/string_util.h"
 #include "base/time/time.h"
 
 #include "courgette/crc.h"
 #include "courgette/streams.h"
@@ skipping 19 matching lines @@
   size_t initial_patch_stream_length = patch_stream->Length();
 
   SinkStreamSet patch_streams;
   SinkStream* control_stream_copy_counts = patch_streams.stream(0);
   SinkStream* control_stream_extra_counts = patch_streams.stream(1);
   SinkStream* control_stream_seeks = patch_streams.stream(2);
   SinkStream* diff_skips = patch_streams.stream(3);
   SinkStream* diff_bytes = patch_streams.stream(4);
   SinkStream* extra_bytes = patch_streams.stream(5);
 
-  const uint8* old = old_stream->Buffer();
+  const uint8_t* old = old_stream->Buffer();
   const int oldsize = static_cast<int>(old_stream->Remaining());
 
-  uint32 pending_diff_zeros = 0;
+  uint32_t pending_diff_zeros = 0;
 
   PagedArray<int> I;
   PagedArray<int> V;
 
   if (!I.Allocate(oldsize + 1)) {
     LOG(ERROR) << "Could not allocate I[], " << ((oldsize + 1) * sizeof(int))
                << " bytes";
     return MEM_ERROR;
   }
 
   if (!V.Allocate(oldsize + 1)) {
     LOG(ERROR) << "Could not allocate V[], " << ((oldsize + 1) * sizeof(int))
                << " bytes";
     return MEM_ERROR;
   }
 
   base::Time q_start_time = base::Time::Now();
   qsuf::qsufsort<PagedArray<int>&>(I, V, old, oldsize);
   VLOG(1) << " done qsufsort "
           << (base::Time::Now() - q_start_time).InSecondsF();
   V.clear();
 
-  const uint8* newbuf = new_stream->Buffer();
+  const uint8_t* newbuf = new_stream->Buffer();
   const int newsize = static_cast<int>(new_stream->Remaining());
 
   int control_length = 0;
   int diff_bytes_length = 0;
   int diff_bytes_nonzero = 0;
   int extra_bytes_length = 0;
 
   // The patch format is a sequence of triples <copy,extra,seek> where 'copy' is
   // the number of bytes to copy from the old file (possibly with mistakes),
   // 'extra' is the number of bytes to copy from a stream of fresh bytes, and
@@ skipping 110 matching lines @@
               old[lastpos + lenf - overlap + i]) score++;
           if (newbuf[scan - lenb + i] ==  old[pos - lenb + i]) score--;
           if (score > Ss) { Ss = score; lens = i + 1; }
         }
 
         lenf += lens - overlap;
         lenb -= lens;
       };
 
       for (int i = 0;  i < lenf;  i++) {
-        uint8 diff_byte = newbuf[lastscan + i] - old[lastpos + i];
+        uint8_t diff_byte = newbuf[lastscan + i] - old[lastpos + i];
         if (diff_byte) {
           ++diff_bytes_nonzero;
           if (!diff_skips->WriteVarint32(pending_diff_zeros))
             return MEM_ERROR;
           pending_diff_zeros = 0;
           if (!diff_bytes->Write(&diff_byte, 1))
             return MEM_ERROR;
         } else {
           ++pending_diff_zeros;
         }
       }
       int gap = (scan - lenb) - (lastscan + lenf);
       for (int i = 0;  i < gap;  i++) {
         if (!extra_bytes->Write(&newbuf[lastscan + lenf + i], 1))
           return MEM_ERROR;
       }
 
       diff_bytes_length += lenf;
       extra_bytes_length += gap;
 
-      uint32 copy_count = lenf;
-      uint32 extra_count = gap;
-      int32 seek_adjustment = ((pos - lenb) - (lastpos + lenf));
+      uint32_t copy_count = lenf;
+      uint32_t extra_count = gap;
+      int32_t seek_adjustment = ((pos - lenb) - (lastpos + lenf));
 
       if (!control_stream_copy_counts->WriteVarint32(copy_count) ||
           !control_stream_extra_counts->WriteVarint32(extra_count) ||
           !control_stream_seeks->WriteVarint32Signed(seek_adjustment)) {
         return MEM_ERROR;
       }
 
       ++control_length;
 #ifdef DEBUG_bsmedberg
       VLOG(1) << StringPrintf("Writing a block:  copy: %-8u extra: %-8u seek: "
@@ skipping 35 matching lines @@
           << "  extra bytes: " << extra_bytes_length
           << "\nUncompressed bsdiff patch size "
           << patch_stream->Length() - initial_patch_stream_length
           << "\nEnd bsdiff "
           << (base::Time::Now() - start_bsdiff_time).InSecondsF();
 
   return OK;
 }
 
 }  // namespace courgette