Switch to standard integer types in courgette/.

courgette/ensemble_apply.cc

 // Copyright (c) 2011 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.
 
 // This file contains the code to apply a Courgette patch.
 
 #include "courgette/ensemble.h"
 
-#include "base/basictypes.h"
+#include <stddef.h>
+#include <stdint.h>
+
 #include "base/files/file_util.h"
 #include "base/files/memory_mapped_file.h"
 #include "base/logging.h"
+#include "base/macros.h"
 #include "courgette/crc.h"
 #include "courgette/patcher_x86_32.h"
 #include "courgette/region.h"
 #include "courgette/simple_delta.h"
 #include "courgette/streams.h"
 
 namespace courgette {
 
 // EnsemblePatchApplication is all the logic and data required to apply the
 // multi-stage patch.
@@ skipping 31 matching lines @@
                              SinkStream* corrected_ensemble);
 
  private:
   Status SubpatchStreamSets(SinkStreamSet* predicted_items,
                             SourceStream* correction,
                             SourceStreamSet* corrected_items,
                             SinkStream* corrected_items_storage);
 
   Region base_region_;       // Location of in-memory copy of 'old' version.
 
-  uint32 source_checksum_;
-  uint32 target_checksum_;
-  uint32 final_patch_input_size_prediction_;
+  uint32_t source_checksum_;
+  uint32_t target_checksum_;
+  uint32_t final_patch_input_size_prediction_;
 
   std::vector<TransformationPatcher*> patchers_;
 
   SinkStream corrected_parameters_storage_;
   SinkStream corrected_elements_storage_;
 
   DISALLOW_COPY_AND_ASSIGN(EnsemblePatchApplication);
 };
 
 EnsemblePatchApplication::EnsemblePatchApplication()
     : source_checksum_(0), target_checksum_(0),
       final_patch_input_size_prediction_(0) {
 }
 
 EnsemblePatchApplication::~EnsemblePatchApplication() {
   for (size_t i = 0;  i < patchers_.size();  ++i) {
     delete patchers_[i];
   }
 }
 
 Status EnsemblePatchApplication::ReadHeader(SourceStream* header_stream) {
-  uint32 magic;
+  uint32_t magic;
   if (!header_stream->ReadVarint32(&magic))
     return C_BAD_ENSEMBLE_MAGIC;
 
   if (magic != CourgettePatchFile::kMagic)
     return C_BAD_ENSEMBLE_MAGIC;
 
-  uint32 version;
+  uint32_t version;
   if (!header_stream->ReadVarint32(&version))
     return C_BAD_ENSEMBLE_VERSION;
 
   if (version != CourgettePatchFile::kVersion)
     return C_BAD_ENSEMBLE_VERSION;
 
   if (!header_stream->ReadVarint32(&source_checksum_))
     return C_BAD_ENSEMBLE_HEADER;
 
   if (!header_stream->ReadVarint32(&target_checksum_))
     return C_BAD_ENSEMBLE_HEADER;
 
   if (!header_stream->ReadVarint32(&final_patch_input_size_prediction_))
     return C_BAD_ENSEMBLE_HEADER;
 
   return C_OK;
 }
 
 Status EnsemblePatchApplication::InitBase(const Region& region) {
   base_region_.assign(region);
   return C_OK;
 }
 
 Status EnsemblePatchApplication::ValidateBase() {
-  uint32 checksum = CalculateCrc(base_region_.start(), base_region_.length());
+  uint32_t checksum = CalculateCrc(base_region_.start(), base_region_.length());
   if (source_checksum_ != checksum)
     return C_BAD_ENSEMBLE_CRC;
 
   return C_OK;
 }
 
 Status EnsemblePatchApplication::ReadInitialParameters(
     SourceStream* transformation_parameters) {
-  uint32 number_of_transformations = 0;
+  uint32_t number_of_transformations = 0;
   if (!transformation_parameters->ReadVarint32(&number_of_transformations))
     return C_BAD_ENSEMBLE_HEADER;
 
   for (size_t i = 0;  i < number_of_transformations;  ++i) {
-    uint32 kind;
+    uint32_t kind;
     if (!transformation_parameters->ReadVarint32(&kind))
       return C_BAD_ENSEMBLE_HEADER;
 
     TransformationPatcher* patcher = NULL;
 
     switch (kind)
     {
       case EXE_WIN_32_X86:
         patcher = new PatcherX86_32(base_region_);
         break;
@@ skipping 275 matching lines @@
           static_cast<int>(new_sink_stream.Length()));
   if (written == -1)
     return C_WRITE_OPEN_ERROR;
   if (static_cast<size_t>(written) != new_sink_stream.Length())
     return C_WRITE_ERROR;
 
   return C_OK;
 }
 
 }  // namespace