diff options
Diffstat (limited to 'deps/v8/src/api.cc')
| -rw-r--r-- | deps/v8/src/api.cc | 344 |
1 files changed, 233 insertions, 111 deletions
diff --git a/deps/v8/src/api.cc b/deps/v8/src/api.cc index 7099ca8ddd..20496fefde 100644 --- a/deps/v8/src/api.cc +++ b/deps/v8/src/api.cc @@ -25,9 +25,6 @@ // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. -// TODO(dcarney): remove -#define V8_ALLOW_ACCESS_TO_PERSISTENT_IMPLICIT - #include "api.h" #include <string.h> // For memcpy, strlen. @@ -35,6 +32,7 @@ #include "../include/v8-debug.h" #include "../include/v8-profiler.h" #include "../include/v8-testing.h" +#include "assert-scope.h" #include "bootstrapper.h" #include "code-stubs.h" #include "compiler.h" @@ -625,31 +623,22 @@ i::Object** V8::GlobalizeReference(i::Isolate* isolate, i::Object** obj) { } -void V8::MakeWeak(i::Isolate* isolate, - i::Object** object, +void V8::MakeWeak(i::Object** object, void* parameters, - RevivableCallback weak_reference_callback, - NearDeathCallback near_death_callback) { - ASSERT(isolate == i::Isolate::Current()); - LOG_API(isolate, "MakeWeak"); - isolate->global_handles()->MakeWeak(object, - parameters, - weak_reference_callback, - near_death_callback); + RevivableCallback weak_reference_callback) { + i::GlobalHandles::MakeWeak(object, + parameters, + weak_reference_callback); } -void V8::ClearWeak(i::Isolate* isolate, i::Object** obj) { - LOG_API(isolate, "ClearWeak"); - isolate->global_handles()->ClearWeakness(obj); +void V8::ClearWeak(i::Object** obj) { + i::GlobalHandles::ClearWeakness(obj); } -void V8::DisposeGlobal(i::Isolate* isolate, i::Object** obj) { - ASSERT(isolate == i::Isolate::Current()); - LOG_API(isolate, "DisposeGlobal"); - if (!isolate->IsInitialized()) return; - isolate->global_handles()->Destroy(obj); +void V8::DisposeGlobal(i::Object** obj) { + i::GlobalHandles::Destroy(obj); } // --- H a n d l e s --- @@ -686,19 +675,7 @@ HandleScope::~HandleScope() { void HandleScope::Leave() { - v8::ImplementationUtilities::HandleScopeData* current = - isolate_->handle_scope_data(); - current->level--; - ASSERT(current->level >= 0); - current->next = prev_next_; - if (current->limit != prev_limit_) { - current->limit = prev_limit_; - i::HandleScope::DeleteExtensions(isolate_); - } - -#ifdef ENABLE_EXTRA_CHECKS - i::HandleScope::ZapRange(prev_next_, prev_limit_); -#endif + return i::HandleScope::CloseScope(isolate_, prev_next_, prev_limit_); } @@ -909,7 +886,8 @@ void NeanderArray::add(i::Handle<i::Object> value) { int length = this->length(); int size = obj_.size(); if (length == size - 1) { - i::Handle<i::FixedArray> new_elms = FACTORY->NewFixedArray(2 * size); + i::Factory* factory = i::Isolate::Current()->factory(); + i::Handle<i::FixedArray> new_elms = factory->NewFixedArray(2 * size); for (int i = 0; i < length; i++) new_elms->set(i + 1, get(i)); obj_.value()->set_elements(*new_elms); @@ -985,7 +963,7 @@ void FunctionTemplate::Inherit(v8::Handle<FunctionTemplate> value) { template<typename Callback> static Local<FunctionTemplate> FunctionTemplateNew( - Callback callback_in, + Callback callback, v8::Handle<Value> data, v8::Handle<Signature> signature, int length) { @@ -1001,10 +979,8 @@ static Local<FunctionTemplate> FunctionTemplateNew( int next_serial_number = isolate->next_serial_number(); isolate->set_next_serial_number(next_serial_number + 1); obj->set_serial_number(i::Smi::FromInt(next_serial_number)); - if (callback_in != 0) { + if (callback != 0) { if (data.IsEmpty()) data = v8::Undefined(); - InvocationCallback callback = - i::CallbackTable::Register(isolate, callback_in); Utils::ToLocal(obj)->SetCallHandler(callback, data); } obj->set_length(length); @@ -1228,7 +1204,7 @@ int TypeSwitch::match(v8::Handle<Value> value) { template<typename Callback> static void FunctionTemplateSetCallHandler(FunctionTemplate* function_template, - Callback callback, + Callback callback_in, v8::Handle<Value> data) { i::Isolate* isolate = Utils::OpenHandle(function_template)->GetIsolate(); if (IsDeadCheck(isolate, "v8::FunctionTemplate::SetCallHandler()")) return; @@ -1238,6 +1214,8 @@ static void FunctionTemplateSetCallHandler(FunctionTemplate* function_template, isolate->factory()->NewStruct(i::CALL_HANDLER_INFO_TYPE); i::Handle<i::CallHandlerInfo> obj = i::Handle<i::CallHandlerInfo>::cast(struct_obj); + FunctionCallback callback = + i::CallbackTable::Register(isolate, callback_in); SET_FIELD_WRAPPED(obj, set_callback, callback); if (data.IsEmpty()) data = v8::Undefined(); obj->set_data(*Utils::OpenHandle(*data)); @@ -1284,9 +1262,11 @@ static i::Handle<i::AccessorInfo> MakeAccessorInfo( i::Isolate* isolate = Utils::OpenHandle(*name)->GetIsolate(); i::Handle<i::ExecutableAccessorInfo> obj = isolate->factory()->NewExecutableAccessorInfo(); - AccessorGetter getter = i::CallbackTable::Register(isolate, getter_in); + AccessorGetterCallback getter = + i::CallbackTable::Register(isolate, getter_in); SET_FIELD_WRAPPED(obj, set_getter, getter); - AccessorSetter setter = i::CallbackTable::Register(isolate, setter_in); + AccessorSetterCallback setter = + i::CallbackTable::Register(isolate, setter_in); SET_FIELD_WRAPPED(obj, set_setter, setter); if (data.IsEmpty()) data = v8::Undefined(); obj->set_data(*Utils::OpenHandle(*data)); @@ -1389,16 +1369,19 @@ static void SetNamedInstancePropertyHandler( i::Handle<i::InterceptorInfo> obj = i::Handle<i::InterceptorInfo>::cast(struct_obj); - NamedPropertyGetter getter = i::CallbackTable::Register(isolate, getter_in); + NamedPropertyGetterCallback getter = + i::CallbackTable::Register(isolate, getter_in); if (getter != 0) SET_FIELD_WRAPPED(obj, set_getter, getter); - NamedPropertySetter setter = i::CallbackTable::Register(isolate, setter_in); + NamedPropertySetterCallback setter = + i::CallbackTable::Register(isolate, setter_in); if (setter != 0) SET_FIELD_WRAPPED(obj, set_setter, setter); - NamedPropertyQuery query = i::CallbackTable::Register(isolate, query_in); + NamedPropertyQueryCallback query = + i::CallbackTable::Register(isolate, query_in); if (query != 0) SET_FIELD_WRAPPED(obj, set_query, query); - NamedPropertyDeleter remover = + NamedPropertyDeleterCallback remover = i::CallbackTable::Register(isolate, remover_in); if (remover != 0) SET_FIELD_WRAPPED(obj, set_deleter, remover); - NamedPropertyEnumerator enumerator = + NamedPropertyEnumeratorCallback enumerator = i::CallbackTable::Register(isolate, enumerator_in); if (enumerator != 0) SET_FIELD_WRAPPED(obj, set_enumerator, enumerator); @@ -1434,18 +1417,19 @@ static void SetIndexedInstancePropertyHandler( i::Handle<i::InterceptorInfo> obj = i::Handle<i::InterceptorInfo>::cast(struct_obj); - IndexedPropertyGetter getter = + IndexedPropertyGetterCallback getter = i::CallbackTable::Register(isolate, getter_in); if (getter != 0) SET_FIELD_WRAPPED(obj, set_getter, getter); - IndexedPropertySetter setter = + IndexedPropertySetterCallback setter = i::CallbackTable::Register(isolate, setter_in); if (setter != 0) SET_FIELD_WRAPPED(obj, set_setter, setter); - IndexedPropertyQuery query = i::CallbackTable::Register(isolate, query_in); + IndexedPropertyQueryCallback query = + i::CallbackTable::Register(isolate, query_in); if (query != 0) SET_FIELD_WRAPPED(obj, set_query, query); - IndexedPropertyDeleter remover = + IndexedPropertyDeleterCallback remover = i::CallbackTable::Register(isolate, remover_in); if (remover != 0) SET_FIELD_WRAPPED(obj, set_deleter, remover); - IndexedPropertyEnumerator enumerator = + IndexedPropertyEnumeratorCallback enumerator = i::CallbackTable::Register(isolate, enumerator_in); if (enumerator != 0) SET_FIELD_WRAPPED(obj, set_enumerator, enumerator); @@ -1471,7 +1455,7 @@ static void SetInstanceCallAsFunctionHandler( isolate->factory()->NewStruct(i::CALL_HANDLER_INFO_TYPE); i::Handle<i::CallHandlerInfo> obj = i::Handle<i::CallHandlerInfo>::cast(struct_obj); - InvocationCallback callback = + FunctionCallback callback = i::CallbackTable::Register(isolate, callback_in); SET_FIELD_WRAPPED(obj, set_callback, callback); if (data.IsEmpty()) data = v8::Undefined(); @@ -3879,7 +3863,8 @@ v8::Local<v8::Value> v8::Object::GetHiddenValue(v8::Handle<v8::String> key) { ENTER_V8(isolate); i::Handle<i::JSObject> self = Utils::OpenHandle(this); i::Handle<i::String> key_obj = Utils::OpenHandle(*key); - i::Handle<i::String> key_string = FACTORY->InternalizeString(key_obj); + i::Handle<i::String> key_string = + isolate->factory()->InternalizeString(key_obj); i::Handle<i::Object> result(self->GetHiddenProperty(*key_string), isolate); if (result->IsUndefined()) return v8::Local<v8::Value>(); return Utils::ToLocal(result); @@ -3893,7 +3878,8 @@ bool v8::Object::DeleteHiddenValue(v8::Handle<v8::String> key) { i::HandleScope scope(isolate); i::Handle<i::JSObject> self = Utils::OpenHandle(this); i::Handle<i::String> key_obj = Utils::OpenHandle(*key); - i::Handle<i::String> key_string = FACTORY->InternalizeString(key_obj); + i::Handle<i::String> key_string = + isolate->factory()->InternalizeString(key_obj); self->DeleteHiddenProperty(*key_string); return true; } @@ -4317,6 +4303,124 @@ bool String::IsOneByte() const { return str->HasOnlyOneByteChars(); } +// Helpers for ContainsOnlyOneByteHelper +template<size_t size> struct OneByteMask; +template<> struct OneByteMask<4> { + static const uint32_t value = 0xFF00FF00; +}; +template<> struct OneByteMask<8> { + static const uint64_t value = V8_2PART_UINT64_C(0xFF00FF00, FF00FF00); +}; +static const uintptr_t kOneByteMask = OneByteMask<sizeof(uintptr_t)>::value; +static const uintptr_t kAlignmentMask = sizeof(uintptr_t) - 1; +static inline bool Unaligned(const uint16_t* chars) { + return reinterpret_cast<const uintptr_t>(chars) & kAlignmentMask; +} +static inline const uint16_t* Align(const uint16_t* chars) { + return reinterpret_cast<uint16_t*>( + reinterpret_cast<uintptr_t>(chars) & ~kAlignmentMask); +} + +class ContainsOnlyOneByteHelper { + public: + ContainsOnlyOneByteHelper() : is_one_byte_(true) {} + bool Check(i::String* string) { + i::ConsString* cons_string = i::String::VisitFlat(this, string, 0); + if (cons_string == NULL) return is_one_byte_; + return CheckCons(cons_string); + } + void VisitOneByteString(const uint8_t* chars, int length) { + // Nothing to do. + } + void VisitTwoByteString(const uint16_t* chars, int length) { + // Accumulated bits. + uintptr_t acc = 0; + // Align to uintptr_t. + const uint16_t* end = chars + length; + while (Unaligned(chars) && chars != end) { + acc |= *chars++; + } + // Read word aligned in blocks, + // checking the return value at the end of each block. + const uint16_t* aligned_end = Align(end); + const int increment = sizeof(uintptr_t)/sizeof(uint16_t); + const int inner_loops = 16; + while (chars + inner_loops*increment < aligned_end) { + for (int i = 0; i < inner_loops; i++) { + acc |= *reinterpret_cast<const uintptr_t*>(chars); + chars += increment; + } + // Check for early return. + if ((acc & kOneByteMask) != 0) { + is_one_byte_ = false; + return; + } + } + // Read the rest. + while (chars != end) { + acc |= *chars++; + } + // Check result. + if ((acc & kOneByteMask) != 0) is_one_byte_ = false; + } + + private: + bool CheckCons(i::ConsString* cons_string) { + while (true) { + // Check left side if flat. + i::String* left = cons_string->first(); + i::ConsString* left_as_cons = + i::String::VisitFlat(this, left, 0); + if (!is_one_byte_) return false; + // Check right side if flat. + i::String* right = cons_string->second(); + i::ConsString* right_as_cons = + i::String::VisitFlat(this, right, 0); + if (!is_one_byte_) return false; + // Standard recurse/iterate trick. + if (left_as_cons != NULL && right_as_cons != NULL) { + if (left->length() < right->length()) { + CheckCons(left_as_cons); + cons_string = right_as_cons; + } else { + CheckCons(right_as_cons); + cons_string = left_as_cons; + } + // Check fast return. + if (!is_one_byte_) return false; + continue; + } + // Descend left in place. + if (left_as_cons != NULL) { + cons_string = left_as_cons; + continue; + } + // Descend right in place. + if (right_as_cons != NULL) { + cons_string = right_as_cons; + continue; + } + // Terminate. + break; + } + return is_one_byte_; + } + bool is_one_byte_; + DISALLOW_COPY_AND_ASSIGN(ContainsOnlyOneByteHelper); +}; + + +bool String::ContainsOnlyOneByte() const { + i::Handle<i::String> str = Utils::OpenHandle(this); + if (IsDeadCheck(str->GetIsolate(), + "v8::String::ContainsOnlyOneByte()")) { + return false; + } + if (str->HasOnlyOneByteChars()) return true; + ContainsOnlyOneByteHelper helper; + return helper.Check(*str); +} + class Utf8LengthHelper : public i::AllStatic { public: @@ -5056,6 +5160,15 @@ void v8::V8::SetJitCodeEventHandler( isolate->logger()->SetCodeEventHandler(options, event_handler); } +void v8::V8::SetArrayBufferAllocator( + ArrayBuffer::Allocator* allocator) { + if (!ApiCheck(i::V8::ArrayBufferAllocator() == NULL, + "v8::V8::SetArrayBufferAllocator", + "ArrayBufferAllocator might only be set once")) + return; + i::V8::SetArrayBufferAllocator(allocator); +} + bool v8::V8::Dispose() { i::Isolate* isolate = i::Isolate::Current(); @@ -5107,8 +5220,9 @@ class VisitorAdapter : public i::ObjectVisitor { UNREACHABLE(); } virtual void VisitEmbedderReference(i::Object** p, uint16_t class_id) { - visitor_->VisitPersistentHandle(ToApi<Value>(i::Handle<i::Object>(p)), - class_id); + Value* value = ToApi<Value>(i::Handle<i::Object>(p)); + visitor_->VisitPersistentHandle( + reinterpret_cast<Persistent<Value>*>(&value), class_id); } private: PersistentHandleVisitor* visitor_; @@ -5119,7 +5233,7 @@ void v8::V8::VisitHandlesWithClassIds(PersistentHandleVisitor* visitor) { i::Isolate* isolate = i::Isolate::Current(); IsDeadCheck(isolate, "v8::V8::VisitHandlesWithClassId"); - i::AssertNoAllocation no_allocation; + i::DisallowHeapAllocation no_allocation; VisitorAdapter visitor_adapter(visitor); isolate->global_handles()->IterateAllRootsWithClassIds(&visitor_adapter); @@ -5132,7 +5246,7 @@ void v8::V8::VisitHandlesForPartialDependence( ASSERT(isolate == i::Isolate::Current()); IsDeadCheck(isolate, "v8::V8::VisitHandlesForPartialDependence"); - i::AssertNoAllocation no_allocation; + i::DisallowHeapAllocation no_allocation; VisitorAdapter visitor_adapter(visitor); isolate->global_handles()->IterateAllRootsInNewSpaceWithClassIds( @@ -5914,13 +6028,14 @@ void v8::Date::DateTimeConfigurationChangeNotification() { static i::Handle<i::String> RegExpFlagsToString(RegExp::Flags flags) { + i::Isolate* isolate = i::Isolate::Current(); uint8_t flags_buf[3]; int num_flags = 0; if ((flags & RegExp::kGlobal) != 0) flags_buf[num_flags++] = 'g'; if ((flags & RegExp::kMultiline) != 0) flags_buf[num_flags++] = 'm'; if ((flags & RegExp::kIgnoreCase) != 0) flags_buf[num_flags++] = 'i'; ASSERT(num_flags <= static_cast<int>(ARRAY_SIZE(flags_buf))); - return FACTORY->InternalizeOneByteString( + return isolate->factory()->InternalizeOneByteString( i::Vector<const uint8_t>(flags_buf, num_flags)); } @@ -6019,19 +6134,48 @@ Local<Object> Array::CloneElementAt(uint32_t index) { } -size_t v8::ArrayBuffer::ByteLength() const { - i::Isolate* isolate = Utils::OpenHandle(this)->GetIsolate(); - if (IsDeadCheck(isolate, "v8::ArrayBuffer::ByteLength()")) return 0; +bool v8::ArrayBuffer::IsExternal() const { + return Utils::OpenHandle(this)->is_external(); +} + +v8::ArrayBuffer::Contents v8::ArrayBuffer::Externalize() { i::Handle<i::JSArrayBuffer> obj = Utils::OpenHandle(this); - return static_cast<size_t>(obj->byte_length()->Number()); + ApiCheck(!obj->is_external(), + "v8::ArrayBuffer::Externalize", + "ArrayBuffer already externalized"); + obj->set_is_external(true); + size_t byte_length = static_cast<size_t>(obj->byte_length()->Number()); + Contents contents; + contents.data_ = obj->backing_store(); + contents.byte_length_ = byte_length; + return contents; } -void* v8::ArrayBuffer::Data() const { +void v8::ArrayBuffer::Neuter() { + i::Handle<i::JSArrayBuffer> obj = Utils::OpenHandle(this); + i::Isolate* isolate = obj->GetIsolate(); + ApiCheck(obj->is_external(), + "v8::ArrayBuffer::Neuter", + "Only externalized ArrayBuffers can be neutered"); + LOG_API(obj->GetIsolate(), "v8::ArrayBuffer::Neuter()"); + ENTER_V8(isolate); + + for (i::Handle<i::Object> array_obj(obj->weak_first_array(), isolate); + *array_obj != i::Smi::FromInt(0);) { + i::Handle<i::JSTypedArray> typed_array(i::JSTypedArray::cast(*array_obj)); + typed_array->Neuter(); + array_obj = i::handle(typed_array->weak_next(), isolate); + } + obj->Neuter(); +} + + +size_t v8::ArrayBuffer::ByteLength() const { i::Isolate* isolate = Utils::OpenHandle(this)->GetIsolate(); - if (IsDeadCheck(isolate, "v8::ArrayBuffer::Data()")) return 0; + if (IsDeadCheck(isolate, "v8::ArrayBuffer::ByteLength()")) return 0; i::Handle<i::JSArrayBuffer> obj = Utils::OpenHandle(this); - return obj->backing_store(); + return static_cast<size_t>(obj->byte_length()->Number()); } @@ -6054,7 +6198,7 @@ Local<ArrayBuffer> v8::ArrayBuffer::New(void* data, size_t byte_length) { ENTER_V8(isolate); i::Handle<i::JSArrayBuffer> obj = isolate->factory()->NewJSArrayBuffer(); - i::Runtime::SetupArrayBuffer(isolate, obj, data, byte_length); + i::Runtime::SetupArrayBuffer(isolate, obj, true, data, byte_length); return Utils::ToLocal(obj); } @@ -6121,6 +6265,9 @@ i::Handle<i::JSTypedArray> NewTypedArray( obj->set_buffer(*buffer); + obj->set_weak_next(buffer->weak_first_array()); + buffer->set_weak_first_array(*obj); + i::Handle<i::Object> byte_offset_object = isolate->factory()->NewNumber( static_cast<double>(byte_offset)); obj->set_byte_offset(*byte_offset_object); @@ -6265,14 +6412,12 @@ Local<Integer> v8::Integer::NewFromUnsigned(uint32_t value, Isolate* isolate) { #ifdef DEBUG -v8::AssertNoGCScope::AssertNoGCScope(v8::Isolate* isolate) - : isolate_(isolate), - last_state_(i::EnterAllocationScope( - reinterpret_cast<i::Isolate*>(isolate), false)) { +v8::AssertNoGCScope::AssertNoGCScope(v8::Isolate* isolate) { + disallow_heap_allocation_ = new i::DisallowHeapAllocation(); } v8::AssertNoGCScope::~AssertNoGCScope() { - i::ExitAllocationScope(reinterpret_cast<i::Isolate*>(isolate_), last_state_); + delete static_cast<i::DisallowHeapAllocation*>(disallow_heap_allocation_); } #endif @@ -6359,42 +6504,6 @@ void V8::SetFailedAccessCheckCallbackFunction( } -void V8::AddObjectGroup(Persistent<Value>* objects, - size_t length, - RetainedObjectInfo* info) { - i::Isolate* isolate = i::Isolate::Current(); - if (IsDeadCheck(isolate, "v8::V8::AddObjectGroup()")) return; - STATIC_ASSERT(sizeof(Persistent<Value>) == sizeof(i::Object**)); - isolate->global_handles()->AddObjectGroup( - reinterpret_cast<i::Object***>(objects), length, info); -} - - -void V8::AddObjectGroup(Isolate* exported_isolate, - Persistent<Value>* objects, - size_t length, - RetainedObjectInfo* info) { - i::Isolate* isolate = reinterpret_cast<i::Isolate*>(exported_isolate); - ASSERT(isolate == i::Isolate::Current()); - if (IsDeadCheck(isolate, "v8::V8::AddObjectGroup()")) return; - STATIC_ASSERT(sizeof(Persistent<Value>) == sizeof(i::Object**)); - isolate->global_handles()->AddObjectGroup( - reinterpret_cast<i::Object***>(objects), length, info); -} - - -void V8::AddImplicitReferences(Persistent<Object> parent, - Persistent<Value>* children, - size_t length) { - i::Isolate* isolate = i::Isolate::Current(); - if (IsDeadCheck(isolate, "v8::V8::AddImplicitReferences()")) return; - STATIC_ASSERT(sizeof(Persistent<Value>) == sizeof(i::Object**)); - isolate->global_handles()->AddImplicitReferences( - i::Handle<i::HeapObject>::cast(Utils::OpenHandle(*parent)).location(), - reinterpret_cast<i::Object***>(children), length); -} - - intptr_t Isolate::AdjustAmountOfExternalAllocatedMemory( intptr_t change_in_bytes) { i::Heap* heap = reinterpret_cast<i::Isolate*>(this)->heap(); @@ -7228,6 +7337,12 @@ const CpuProfile* CpuProfiler::GetCpuProfile(int index, } +const CpuProfile* CpuProfiler::GetCpuProfile(int index) { + return reinterpret_cast<const CpuProfile*>( + reinterpret_cast<i::CpuProfiler*>(this)->GetProfile(NULL, index)); +} + + const CpuProfile* CpuProfiler::FindProfile(unsigned uid, Handle<Value> security_token) { i::Isolate* isolate = i::Isolate::Current(); @@ -7287,6 +7402,14 @@ const CpuProfile* CpuProfiler::StopCpuProfiling(Handle<String> title, } +const CpuProfile* CpuProfiler::StopCpuProfiling(Handle<String> title) { + return reinterpret_cast<const CpuProfile*>( + reinterpret_cast<i::CpuProfiler*>(this)->StopProfiling( + NULL, + *Utils::OpenHandle(*title))); +} + + void CpuProfiler::DeleteAllProfiles() { i::Isolate* isolate = i::Isolate::Current(); IsDeadCheck(isolate, "v8::CpuProfiler::DeleteAllProfiles"); @@ -7826,8 +7949,7 @@ DeferredHandles* HandleScopeImplementer::Detach(Object** prev_limit) { while (!blocks_.is_empty()) { Object** block_start = blocks_.last(); Object** block_limit = &block_start[kHandleBlockSize]; - // We should not need to check for NoHandleAllocation here. Assert - // this. + // We should not need to check for SealHandleScope here. Assert this. ASSERT(prev_limit == block_limit || !(block_start <= prev_limit && prev_limit <= block_limit)); if (prev_limit == block_limit) break; |