Another round of cleanups for http://www.dartbug.com/15922

runtime/vm/snapshot.h

 // Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 #ifndef VM_SNAPSHOT_H_
 #define VM_SNAPSHOT_H_
 
 #include "platform/assert.h"
 #include "vm/allocation.h"
 #include "vm/bitfield.h"
@@ skipping 111 matching lines @@
 // header anymore.  This is pending on making the embedder pass in the
 // length of their snapshot.
 class Snapshot {
  public:
   enum Kind {
     kFull = 0,  // Full snapshot of the current dart heap.
     kScript,    // A partial snapshot of only the application script.
     kMessage,   // A partial snapshot used only for isolate messaging.
   };
 
-  static const int kHeaderSize = 2 * sizeof(int32_t);
+  static const int kHeaderSize = 2 * sizeof(int64_t);

[Anders Johnsen, 2014/02/18 10:02:34]

this will assign a size_t to int?

   static const int kLengthIndex = 0;
   static const int kSnapshotFlagIndex = 1;
 
   static const Snapshot* SetupFromBuffer(const void* raw_memory);
 
   // Getters.
   const uint8_t* content() const { return content_; }
-  int32_t length() const { return length_; }
+  int64_t length() const { return length_; }
   Kind kind() const { return static_cast<Kind>(kind_); }
 
   bool IsMessageSnapshot() const { return kind_ == kMessage; }
   bool IsScriptSnapshot() const { return kind_ == kScript; }
   bool IsFullSnapshot() const { return kind_ == kFull; }
   uint8_t* Addr() { return reinterpret_cast<uint8_t*>(this); }
 
   static intptr_t length_offset() { return OFFSET_OF(Snapshot, length_); }
   static intptr_t kind_offset() {
     return OFFSET_OF(Snapshot, kind_);
   }
 
  private:
   Snapshot() : length_(0), kind_(kFull) {}
 
-  int32_t length_;  // Stream length.
-  int32_t kind_;  // Kind of snapshot.
+  int64_t length_;  // Stream length.
+  int64_t kind_;  // Kind of snapshot.

[Anders Johnsen, 2014/02/18 10:02:34]

Why is kind int64?

[Ivan Posva, 2014/02/19 04:04:23]

So that it is easier to deal with and that you do not get any alignment issues.
See the kHeaderSize calculation above.

   uint8_t content_[];  // Stream content.
 
   DISALLOW_COPY_AND_ASSIGN(Snapshot);
 };
 
 
 class BaseReader {
  public:
   BaseReader(const uint8_t* buffer, intptr_t size) : stream_(buffer, size) {}
   // Reads raw data (for basic types).
@@ skipping 261 matching lines @@
     ASSERT(alloc != NULL);
   }
   ~BaseWriter() { }
 
   void ReserveHeader() {
     // Make room for recording snapshot buffer size.
     stream_.set_current(stream_.buffer() + Snapshot::kHeaderSize);
   }
 
   void FillHeader(Snapshot::Kind kind) {
-    int32_t* data = reinterpret_cast<int32_t*>(stream_.buffer());
+    int64_t* data = reinterpret_cast<int64_t*>(stream_.buffer());
     data[Snapshot::kLengthIndex] = stream_.bytes_written();
     data[Snapshot::kSnapshotFlagIndex] = kind;
   }
 
  private:
   WriteStream stream_;
 
   DISALLOW_IMPLICIT_CONSTRUCTORS(BaseWriter);
 };
 
@@ skipping 169 matching lines @@
  private:
   SnapshotWriter* writer_;
   bool as_references_;
 
   DISALLOW_COPY_AND_ASSIGN(SnapshotWriterVisitor);
 };
 
 }  // namespace dart
 
 #endif  // VM_SNAPSHOT_H_