Use ByteArray's native for Socket and File.

runtime/vm/object.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_OBJECT_H_
 #define VM_OBJECT_H_
 
 #include "include/dart_api.h"
 #include "platform/assert.h"
 #include "platform/utils.h"
@@ skipping 3232 matching lines @@
  private:
   HEAP_OBJECT_IMPLEMENTATION(ImmutableArray, Array);
   friend class Class;
 };
 
 
 class ByteArray : public Instance {
  public:
   virtual intptr_t Length() const;
 
+  static void Copy(uint8_t* dst,
+                   const ByteArray& src,
+                   intptr_t src_byte_offset,

[cshapiro, 2012/01/27 23:00:04]

You can probably shorten src_byte_offset to just src_offset here and elsewhere
as the type is implied.  I used the term byte offset to make it clear that even
with the template types, the index was always in terms of bytes and not scaled
byte the template argument.  It's pretty clear here.

[Anders Johnsen, 2012/01/27 23:42:39]

Done.

+                   intptr_t length);
+
+  static void Copy(const ByteArray& dst,
+                   intptr_t dst_byte_offset,
+                   const uint8_t* src,
+                   intptr_t length);
+
+  static void Copy(const ByteArray& dst,
+                   intptr_t dst_byte_offset,
+                   const ByteArray& src,
+                   intptr_t src_byte_offset,
+                   intptr_t length);
+
  private:
+  virtual uint8_t* ByteAddr(intptr_t byte_offset) const;
+
   HEAP_OBJECT_IMPLEMENTATION(ByteArray, Instance);
   friend class Class;
 };
 
 
 class InternalByteArray : public ByteArray {
  public:
   intptr_t Length() const {
     ASSERT(!IsNull());
     return Smi::Value(raw_ptr()->length_);
@@ skipping 43 matching lines @@
     return RoundedAllocationSize(sizeof(RawInternalByteArray) + len);
   }
 
   static RawInternalByteArray* New(intptr_t len,
                                    Heap::Space space = Heap::kNew);
   static RawInternalByteArray* New(const uint8_t* data,
                                    intptr_t len,
                                    Heap::Space space = Heap::kNew);
 
  private:
+  uint8_t* ByteAddr(intptr_t byte_offset) const {
+    return Addr<uint8_t>(byte_offset);
+  }
+
   template<typename T>
   T* Addr(intptr_t byte_offset) const {
     intptr_t limit = byte_offset + sizeof(T);
     // TODO(iposva): Determine if we should throw an exception here.
     ASSERT((byte_offset >= 0) && (limit <= Length()));
     uint8_t* addr = &raw_ptr()->data()[byte_offset];
     return reinterpret_cast<T*>(addr);
   }
 
   void SetLength(intptr_t value) {
@@ skipping 40 matching lines @@
 
   static intptr_t InstanceSize() {
     return RoundedAllocationSize(sizeof(RawExternalByteArray));
   }
 
   static RawExternalByteArray* New(uint8_t* data,
                                    intptr_t len,
                                    Heap::Space space = Heap::kNew);
 
  private:
+  uint8_t* ByteAddr(intptr_t byte_offset) const {
+    return Addr<uint8_t>(byte_offset);
+  }
+
   template<typename T>
   T* Addr(intptr_t byte_offset) const {
     intptr_t limit = byte_offset + sizeof(T);
     // TODO(iposva): Determine if we should throw an exception here.
     ASSERT((byte_offset >= 0) && (limit <= Length()));
     uint8_t* addr = &raw_ptr()->data_[byte_offset];
     return reinterpret_cast<T*>(addr);
   }
 
   void SetLength(intptr_t value) {
@@ skipping 215 matching lines @@
 }
 
 
 void Context::SetAt(intptr_t index, const Instance& value) const {
   StorePointer(InstanceAddr(index), value.raw());
 }
 
 }  // namespace dart
 
 #endif  // VM_OBJECT_H_