Add Blob API

src/api.cc

 // Copyright 2009 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 1498 matching lines @@
   return Utils::OpenHandle(this)->IsBoolean();
 }
 
 
 bool Value::IsExternal() const {
   if (IsDeadCheck("v8::Value::IsExternal()")) return false;
   return Utils::OpenHandle(this)->IsProxy();
 }
 
 
+bool Value::IsBlob() const {
+  if (IsDeadCheck("v8::Value::IsBlob()")) return false;
+  return Utils::OpenHandle(this)->IsByteArray();
+}
+
+
 bool Value::IsInt32() const {
   if (IsDeadCheck("v8::Value::IsInt32()")) return false;
   i::Handle<i::Object> obj = Utils::OpenHandle(this);
   if (obj->IsSmi()) return true;
   if (obj->IsNumber()) {
     double value = obj->Number();
     return i::FastI2D(i::FastD2I(value)) == value;
   }
   return false;
 }
@@ skipping 107 matching lines @@
 
 void External::CheckCast(v8::Value* that) {
   if (IsDeadCheck("v8::External::Cast()")) return;
   i::Handle<i::Object> obj = Utils::OpenHandle(that);
   ApiCheck(obj->IsProxy(),
            "v8::External::Cast()",
            "Could not convert to external");
 }
 
 
+void Blob::CheckCast(v8::Value* that) {
+  if (IsDeadCheck("v8::Blob::Cast()")) return;
+  i::Handle<i::Object> obj = Utils::OpenHandle(that);
+  ApiCheck(obj->IsByteArray(),
+           "v8::Blob::Cast()",
+           "Could not convert to external");

[Christian Plesner Hansen, 2009/11/16 12:12:22]

I expect you mean "...to blob".

+}
+
+
 void v8::Object::CheckCast(Value* that) {
   if (IsDeadCheck("v8::Object::Cast()")) return;
   i::Handle<i::Object> obj = Utils::OpenHandle(that);
   ApiCheck(obj->IsJSObject(),
            "v8::Object::Cast()",
            "Could not convert to object");
 }
 
 
 void v8::Function::CheckCast(Value* that) {
@@ skipping 1291 matching lines @@
 }
 
 
 void* External::Value() const {
   if (IsDeadCheck("v8::External::Value()")) return 0;
   i::Handle<i::Object> obj = Utils::OpenHandle(this);
   return ExternalValueImpl(obj);
 }
 
 
+Local<Blob> v8::Blob::New(int length) {
+  LOG_API("Blob::New");
+  EnsureInitialized("v8::Blob::New()");
+  ENTER_V8;
+  return Utils::ToLocal(i::Factory::NewByteArray(length));
+}
+
+
+int Blob::ByteCount() {
+  if (IsDeadCheck("v8::Blob::ByteCount()")) return 0;
+  i::Handle<i::Object> obj = Utils::OpenHandle(this);

[Christian Plesner Hansen, 2009/11/16 12:12:22]

Doesn't OpenHandle give you back a ByteArray that you can just use without
casting?

+  return i::ByteArray::cast(*obj)->length();
+}
+
+
+uint8_t Blob::GetByte(int index) {
+  if (IsDeadCheck("v8::Blob::GetByte()")) return 0;
+  i::Handle<i::Object> obj = Utils::OpenHandle(this);
+  return i::ByteArray::cast(*obj)->get(index);
+}
+
+
+void Blob::SetByte(int index, uint8_t value) {
+  if (IsDeadCheck("v8::Blob::SetByte()")) return;
+  i::Handle<i::Object> obj = Utils::OpenHandle(this);
+  i::ByteArray::cast(*obj)->set(index, value);
+}
+
+
+uint8_t* Blob::GetAddress() {
+  if (IsDeadCheck("v8::Blob::GetAddress()")) return NULL;
+  i::Handle<i::Object> obj = Utils::OpenHandle(this);
+  return i::ByteArray::cast(*obj)->GetDataStartAddress();

[Christian Plesner Hansen, 2009/11/16 12:12:22]

Danger danger!  This will give you a derived pointer which may be invalidated by
the GC at any time.  The only thing you can do safely is block read/write like
we do on strings.

+}
+
+
 Local<String> v8::String::Empty() {
   EnsureInitialized("v8::String::Empty()");
   LOG_API("String::Empty()");
   return Utils::ToLocal(i::Factory::empty_symbol());
 }
 
 
 Local<String> v8::String::New(const char* data, int length) {
   EnsureInitialized("v8::String::New()");
   LOG_API("String::New(char)");
@@ skipping 895 matching lines @@
 
 
 char* HandleScopeImplementer::Iterate(ObjectVisitor* v, char* storage) {
   HandleScopeImplementer* thread_local =
       reinterpret_cast<HandleScopeImplementer*>(storage);
   thread_local->IterateThis(v);
   return storage + ArchiveSpacePerThread();
 }
 
 } }  // namespace v8::internal