Make assertion scopes thread safe.

src/uri.h

 // Copyright 2013 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 75 matching lines @@
     -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
     -0,  1,  2,  3,  4,  5,  6,  7,  8,  9, -1, -1, -1, -1, -1, -1,
     -1, 10, 11, 12, 13, 14, 15, -1, -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
     -1, 10, 11, 12, 13, 14, 15 };
 
 
 template<typename Char>
 Handle<String> URIUnescape::Unescape(Isolate* isolate, Handle<String> source) {
   int index;
-  { AssertNoAllocation no_allocation;
+  { DisallowHeapAllocation no_allocation;
     StringSearch<uint8_t, Char> search(isolate, STATIC_ASCII_VECTOR("%"));
     index = search.Search(GetCharVector<Char>(source), 0);
     if (index < 0) return source;
   }
   return UnescapeSlow<Char>(isolate, source, index);
 }
 
 
 template <typename Char>
 Handle<String> URIUnescape::UnescapeSlow(
     Isolate* isolate, Handle<String> string, int start_index) {
   bool one_byte = true;
   int length = string->length();
 
   int unescaped_length = 0;
-  { AssertNoAllocation no_allocation;
+  { DisallowHeapAllocation no_allocation;
     Vector<const Char> vector = GetCharVector<Char>(string);
     for (int i = start_index; i < length; unescaped_length++) {
       int step;
       if (UnescapeChar(vector, i, length, &step) >
               String::kMaxOneByteCharCode) {
         one_byte = false;
       }
       i += step;
     }
   }
 
   ASSERT(start_index < length);
   Handle<String> first_part =
       isolate->factory()->NewProperSubString(string, 0, start_index);
 
   int dest_position = 0;
   Handle<String> second_part;
   if (one_byte) {
     Handle<SeqOneByteString> dest =
         isolate->factory()->NewRawOneByteString(unescaped_length);
-    AssertNoAllocation no_allocation;
+    DisallowHeapAllocation no_allocation;
     Vector<const Char> vector = GetCharVector<Char>(string);
     for (int i = start_index; i < length; dest_position++) {
       int step;
       dest->SeqOneByteStringSet(dest_position,
                                 UnescapeChar(vector, i, length, &step));
       i += step;
     }
     second_part = dest;
   } else {
     Handle<SeqTwoByteString> dest =
         isolate->factory()->NewRawTwoByteString(unescaped_length);
-    AssertNoAllocation no_allocation;
+    DisallowHeapAllocation no_allocation;
     Vector<const Char> vector = GetCharVector<Char>(string);
     for (int i = start_index; i < length; dest_position++) {
       int step;
       dest->SeqTwoByteStringSet(dest_position,
                                 UnescapeChar(vector, i, length, &step));
       i += step;
     }
     second_part = dest;
   }
   return isolate->factory()->NewConsString(first_part, second_part);
@@ skipping 86 matching lines @@
     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
 
 
 template<typename Char>
 Handle<String> URIEscape::Escape(Isolate* isolate, Handle<String> string) {
   ASSERT(string->IsFlat());
   int escaped_length = 0;
   int length = string->length();
 
-  { AssertNoAllocation no_allocation;
+  { DisallowHeapAllocation no_allocation;
     Vector<const Char> vector = GetCharVector<Char>(string);
     for (int i = 0; i < length; i++) {
       uint16_t c = vector[i];
       if (c >= 256) {
         escaped_length += 6;
       } else if (IsNotEscaped(c)) {
         escaped_length++;
       } else {
         escaped_length += 3;
       }
 
       // We don't allow strings that are longer than a maximal length.
       ASSERT(String::kMaxLength < 0x7fffffff - 6);  // Cannot overflow.
       if (escaped_length > String::kMaxLength) {
         isolate->context()->mark_out_of_memory();
         return Handle<String>::null();
       }
     }
   }
 
   // No length change implies no change.  Return original string if no change.
   if (escaped_length == length) return string;
 
   Handle<SeqOneByteString> dest =
       isolate->factory()->NewRawOneByteString(escaped_length);
   int dest_position = 0;
 
-  { AssertNoAllocation no_allocation;
+  { DisallowHeapAllocation no_allocation;
     Vector<const Char> vector = GetCharVector<Char>(string);
     for (int i = 0; i < length; i++) {
       uint16_t c = vector[i];
       if (c >= 256) {
         dest->SeqOneByteStringSet(dest_position, '%');
         dest->SeqOneByteStringSet(dest_position+1, 'u');
         dest->SeqOneByteStringSet(dest_position+2, kHexChars[c >> 12]);
         dest->SeqOneByteStringSet(dest_position+3, kHexChars[(c >> 8) & 0xf]);
         dest->SeqOneByteStringSet(dest_position+4, kHexChars[(c >> 4) & 0xf]);
         dest->SeqOneByteStringSet(dest_position+5, kHexChars[c & 0xf]);
         dest_position += 6;
       } else if (IsNotEscaped(c)) {
         dest->SeqOneByteStringSet(dest_position, c);
         dest_position++;
       } else {
         dest->SeqOneByteStringSet(dest_position, '%');
         dest->SeqOneByteStringSet(dest_position+1, kHexChars[c >> 4]);
         dest->SeqOneByteStringSet(dest_position+2, kHexChars[c & 0xf]);
         dest_position += 3;
       }
     }
   }
 
   return dest;
 }
 
 } }  // namespace v8::internal
 
 #endif  // V8_URI_H_