Fix typo in assert.

src/objects.cc

 // Copyright 2011 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 5020 matching lines @@
   Access<StringInputBuffer> buffer(
       heap->isolate()->objects_string_input_buffer());
   buffer->Reset(0, this);
   int result = 0;
   while (buffer->has_more())
     result += unibrow::Utf8::Length(buffer->GetNext());
   return result;
 }
 
 
-String::FlatContent String::GetFlatContent(const AssertNoAllocation& promise) {
-  // Argument isn't used, it's only there to ensure that the user is
-  // aware that the extracted vectors may not survive a GC.
+String::FlatContent String::GetFlatContent() {
   int length = this->length();
   StringShape shape(this);
   String* string = this;
   if (shape.representation_tag() == kConsStringTag) {
     ConsString* cons = ConsString::cast(string);
     if (cons->second()->length() != 0) {
       return FlatContent();
     }
     string = cons->first();
     shape = StringShape(string);
@@ skipping 458 matching lines @@
       str_(0),
       is_ascii_(true),
       length_(input.length()),
       start_(input.start()) { }
 
 
 void FlatStringReader::PostGarbageCollection() {
   if (str_ == NULL) return;
   Handle<String> str(str_);
   ASSERT(str->IsFlat());
-  AssertNoAllocation no_alloc;
-  String::FlatContent content = str->GetFlatContent(no_alloc);
-  ASSERT(content.is_flat());
+  String::FlatContent content = str->GetFlatContent();
+  ASSERT(content.IsFlat());
   is_ascii_ = content.IsAscii();
   if (is_ascii_) {
     start_ = content.ToAsciiVector().start();
   } else {
     start_ = content.ToUC16Vector().start();
   }
 }
 
 
 void StringInputBuffer::Seek(unsigned pos) {
@@ skipping 304 matching lines @@
     }
   }
   return true;
 }
 
 
 template <typename IteratorA>
 static inline bool CompareStringContentsPartial(Isolate* isolate,
                                                 IteratorA* ia,
                                                 String* b) {
-  AssertNoAllocation no_alloc;
-  String::FlatContent content = b->GetFlatContent(no_alloc);
+  String::FlatContent content = b->GetFlatContent();
   if (content.IsFlat()) {
     if (content.IsAscii()) {
       VectorIterator<char> ib(content.ToAsciiVector());
       return CompareStringContents(ia, &ib);
     } else {
       VectorIterator<uc16> ib(content.ToUC16Vector());
       return CompareStringContents(ia, &ib);
     }
   } else {
     isolate->objects_string_compare_buffer_b()->Reset(0, b);
@@ skipping 15 matching lines @@
     if (Hash() != other->Hash()) return false;
   }
 
   // We know the strings are both non-empty. Compare the first chars
   // before we try to flatten the strings.
   if (this->Get(0) != other->Get(0)) return false;
 
   String* lhs = this->TryFlattenGetString();
   String* rhs = other->TryFlattenGetString();
 
-  AssertNoAllocation no_alloc;
-
   if (StringShape(lhs).IsSequentialAscii() &&
       StringShape(rhs).IsSequentialAscii()) {
     const char* str1 = SeqAsciiString::cast(lhs)->GetChars();
     const char* str2 = SeqAsciiString::cast(rhs)->GetChars();
     return CompareRawStringContents(Vector<const char>(str1, len),
                                     Vector<const char>(str2, len));
   }
 
   Isolate* isolate = GetIsolate();
-  String::FlatContent lhs_content = lhs->GetFlatContent(no_alloc);
-  String::FlatContent rhs_content = rhs->GetFlatContent(no_alloc);
+  String::FlatContent lhs_content = lhs->GetFlatContent();
+  String::FlatContent rhs_content = rhs->GetFlatContent();
   if (lhs_content.IsFlat()) {
     if (lhs_content.IsAscii()) {
       Vector<const char> vec1 = lhs_content.ToAsciiVector();
       if (rhs_content.IsFlat()) {
         if (rhs_content.IsAscii()) {
           Vector<const char> vec2 = rhs_content.ToAsciiVector();
           return CompareRawStringContents(vec1, vec2);
         } else {
           VectorIterator<char> buf1(vec1);
           VectorIterator<uc16> ib(rhs_content.ToUC16Vector());
@@ skipping 57 matching lines @@
   int i;
   for (i = 0; i < slen && decoder->has_more(); i++) {
     uc32 r = decoder->GetNext();
     if (Get(i) != r) return false;
   }
   return i == slen && !decoder->has_more();
 }
 
 
 bool String::IsAsciiEqualTo(Vector<const char> str) {
-  AssertNoAllocation no_alloc;
   int slen = length();
   if (str.length() != slen) return false;
-  FlatContent content = GetFlatContent(no_alloc);
+  FlatContent content = GetFlatContent();
   if (content.IsAscii()) {
     return CompareChars(content.ToAsciiVector().start(),
                         str.start(), slen) == 0;
   }
   for (int i = 0; i < slen; i++) {
     if (Get(i) != static_cast<uint16_t>(str[i])) return false;
   }
   return true;
 }
 
 
 bool String::IsTwoByteEqualTo(Vector<const uc16> str) {
-  AssertNoAllocation no_alloc;
   int slen = length();
   if (str.length() != slen) return false;
-  FlatContent content = GetFlatContent(no_alloc);
+  FlatContent content = GetFlatContent();
   if (content.IsTwoByte()) {
     return CompareChars(content.ToUC16Vector().start(), str.start(), slen) == 0;
   }
   for (int i = 0; i < slen; i++) {
     if (Get(i) != str[i]) return false;
   }
   return true;
 }
 
 
@@ skipping 5544 matching lines @@
   if (break_point_objects()->IsUndefined()) return 0;
   // Single break point.
   if (!break_point_objects()->IsFixedArray()) return 1;
   // Multiple break points.
   return FixedArray::cast(break_point_objects())->length();
 }
 #endif
 
 
 } }  // namespace v8::internal