win: fixes for Windows x64

minidump/minidump_writable.cc

 // Copyright 2014 The Crashpad Authors. All rights reserved.
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
 // You may obtain a copy of the License at
 //
 //     http://www.apache.org/licenses/LICENSE-2.0
 //
 // Unless required by applicable law or agreed to in writing, software
 // distributed under the License is distributed on an "AS IS" BASIS,
@@ skipping 25 matching lines @@
 
 bool MinidumpWritable::WriteEverything(FileWriterInterface* file_writer) {
   DCHECK_EQ(state_, kStateMutable);
 
   if (!Freeze()) {
     return false;
   }
 
   DCHECK_EQ(state_, kStateFrozen);
 
-  off_t offset = 0;
+  FileOffset offset = 0;
   std::vector<MinidumpWritable*> write_sequence;
   size_t size = WillWriteAtOffset(kPhaseEarly, &offset, &write_sequence);
   if (size == kInvalidSize) {
     return false;
   }
 
   offset += size;
   if (WillWriteAtOffset(kPhaseLate, &offset, &write_sequence) == kInvalidSize) {
     return false;
   }
@@ skipping 60 matching lines @@
 
   return std::vector<MinidumpWritable*>();
 }
 
 MinidumpWritable::Phase MinidumpWritable::WritePhase() {
   return kPhaseEarly;
 }
 
 size_t MinidumpWritable::WillWriteAtOffset(
     Phase phase,
-    off_t* offset,
+    FileOffset* offset,
     std::vector<MinidumpWritable*>* write_sequence) {
-  off_t local_offset = *offset;
+  FileOffset local_offset = *offset;
   CHECK_GE(local_offset, 0);
 
   size_t leading_pad_bytes_this_phase;
   size_t size;
   if (phase == WritePhase()) {
     DCHECK_EQ(state_, kStateFrozen);
 
     // Add this object to the sequence of MinidumpWritable objects to be
     // written.
     write_sequence->push_back(this);
@@ skipping 71 matching lines @@
     size = 0;
     leading_pad_bytes_this_phase = 0;
   }
 
   // Loop over children regardless of whether this object itself will write
   // during this phase. An object’s children are not required to be written
   // during the same phase as their parent.
   std::vector<MinidumpWritable*> children = Children();
   for (MinidumpWritable* child : children) {
     // Use “auto” here because it’s impossible to know whether size_t (size) or
-    // off_t (local_offset) is the wider type, and thus what type the result of
-    // adding these two variables will have.
+    // FileOffset (local_offset) is the wider type, and thus what type the
+    // result of adding these two variables will have.
     auto unaligned_child_offset = local_offset + size;
-    off_t child_offset;
+    FileOffset child_offset;
     if (!AssignIfInRange(&child_offset, unaligned_child_offset)) {
       LOG(ERROR) << "offset " << unaligned_child_offset << " out of range";
       return kInvalidSize;
     }
 
     size_t child_size =
         child->WillWriteAtOffset(phase, &child_offset, write_sequence);
     if (child_size == kInvalidSize) {
       return kInvalidSize;
     }
 
     size += child_size;
   }
 
   return leading_pad_bytes_this_phase + size;
 }
 
-bool MinidumpWritable::WillWriteAtOffsetImpl(off_t offset) {
+bool MinidumpWritable::WillWriteAtOffsetImpl(FileOffset offset) {
   return true;
 }
 
 bool MinidumpWritable::WritePaddingAndObject(FileWriterInterface* file_writer) {
   DCHECK_EQ(state_, kStateWritable);
 
   // The number of elements in kZeroes must be at least one less than the
   // maximum Alignment() ever encountered.
   const uint8_t kZeroes[kMaximumAlignment - 1] = {};
   DCHECK_LE(leading_pad_bytes_, arraysize(kZeroes));
 
   if (leading_pad_bytes_) {
     if (!file_writer->Write(&kZeroes, leading_pad_bytes_)) {
       return false;
     }
   }
 
   if (!WriteObject(file_writer)) {
     return false;
   }
 
   state_ = kStateWritten;
   return true;
 }
 
 }  // namespace internal
 }  // namespace crashpad