Remove experimental ExternalSymbolCallback feature. This is not needed...

src/heap.cc

 // Copyright 2006-2008 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 66 matching lines @@
 
 // semispace_size_ should be a power of 2 and old_generation_size_ should be
 // a multiple of Page::kPageSize.
 int Heap::semispace_size_  = 2*MB;
 int Heap::old_generation_size_ = 512*MB;
 int Heap::initial_semispace_size_ = 256*KB;
 
 GCCallback Heap::global_gc_prologue_callback_ = NULL;
 GCCallback Heap::global_gc_epilogue_callback_ = NULL;
 
-ExternalSymbolCallback Heap::global_external_symbol_callback_ = NULL;
-
 // Variables set based on semispace_size_ and old_generation_size_ in
 // ConfigureHeap.
 int Heap::young_generation_size_ = 0;  // Will be 2 * semispace_size_.
 
 // Double the new space after this many scavenge collections.
 int Heap::new_space_growth_limit_ = 8;
 int Heap::scavenge_count_ = 0;
 Heap::HeapState Heap::gc_state_ = NOT_IN_GC;
 
 int Heap::mc_count_ = 0;
@@ skipping 1427 matching lines @@
   if (result->IsFailure()) return result;
 
   ExternalTwoByteString* external_string = ExternalTwoByteString::cast(result);
   external_string->set_length(length);
   external_string->set_resource(resource);
 
   return result;
 }
 
 
-Object* Heap::AllocateExternalSymbolFromTwoByte(
-    ExternalTwoByteString::Resource* resource) {
-  int length = resource->length();
-
-  Map* map = ExternalTwoByteString::SymbolMap(length);
-  Object* result = Allocate(map, OLD_DATA_SPACE);
-  if (result->IsFailure()) return result;
-
-  ExternalTwoByteString* external_string = ExternalTwoByteString::cast(result);
-  external_string->set_length(length);
-  external_string->set_resource(resource);
-
-  return result;
-}
-
-
 Object* Heap::LookupSingleCharacterStringFromCode(uint16_t code) {
   if (code <= String::kMaxAsciiCharCode) {
     Object* value = Heap::single_character_string_cache()->get(code);
     if (value != Heap::undefined_value()) return value;
 
     char buffer[1];
     buffer[0] = static_cast<char>(code);
     Object* result = LookupSymbol(Vector<const char>(buffer, 1));
 
     if (result->IsFailure()) return result;
@@ skipping 530 matching lines @@
 }
 
 
 Object* Heap::AllocateInternalSymbol(unibrow::CharacterStream* buffer,
                                      int chars,
                                      uint32_t length_field) {
   // Ensure the chars matches the number of characters in the buffer.
   ASSERT(static_cast<unsigned>(chars) == buffer->Length());
   // Determine whether the string is ascii.
   bool is_ascii = true;
-  while (buffer->has_more()) {
+  while (buffer->has_more() && is_ascii) {
     if (buffer->GetNext() > unibrow::Utf8::kMaxOneByteChar) is_ascii = false;
   }
   buffer->Rewind();
 
   // Compute map and object size.
   int size;
   Map* map;
 
   if (is_ascii) {
     if (chars <= String::kMaxShortStringSize) {
@@ skipping 30 matching lines @@
   ASSERT_EQ(size, answer->Size());
 
   // Fill in the characters.
   for (int i = 0; i < chars; i++) {
     answer->Set(answer_shape, i, buffer->GetNext());
   }
   return answer;
 }
 
 
-// External string resource that only contains a length field.  These
-// are used temporarily when allocating external symbols.
-class DummyExternalStringResource
-    : public v8::String::ExternalStringResource {
- public:
-  explicit DummyExternalStringResource(size_t length) : length_(length) { }
-
-  virtual const uint16_t* data() const {
-    UNREACHABLE();
-    return NULL;
-  }
-
-  virtual size_t length() const { return length_; }
- private:
-  size_t length_;
-};
-
-
-Object* Heap::AllocateExternalSymbol(Vector<const char> string, int chars) {
-  // Attempt to allocate the resulting external string first.  Use a
-  // dummy string resource that has the correct length so that we only
-  // have to patch the external string resource after the callback.
-  DummyExternalStringResource dummy_resource(chars);
-  Object* obj = AllocateExternalSymbolFromTwoByte(&dummy_resource);
-  if (obj->IsFailure()) return obj;
-  // Perform callback.
-  v8::String::ExternalStringResource* resource =
-      global_external_symbol_callback_(string.start(), string.length());
-  // Patch the resource pointer of the result.
-  ExternalTwoByteString* result = ExternalTwoByteString::cast(obj);
-  result->set_resource(resource);
-  // Force hash code to be computed.
-  result->Hash();
-  ASSERT(result->IsEqualTo(string));
-  return result;
-}
-
-
 Object* Heap::AllocateRawAsciiString(int length, PretenureFlag pretenure) {
   AllocationSpace space = (pretenure == TENURED) ? OLD_DATA_SPACE : NEW_SPACE;
   int size = SeqAsciiString::SizeFor(length);
   if (size > MaxHeapObjectSize()) {
     space = LO_SPACE;
   }
 
   // Use AllocateRaw rather than Allocate because the object's size cannot be
   // determined from the map.
   Object* result = AllocateRaw(size, space, OLD_DATA_SPACE);
@@ skipping 1155 matching lines @@
 #ifdef DEBUG
 bool Heap::GarbageCollectionGreedyCheck() {
   ASSERT(FLAG_gc_greedy);
   if (Bootstrapper::IsActive()) return true;
   if (disallow_allocation_failure()) return true;
   return CollectGarbage(0, NEW_SPACE);
 }
 #endif
 
 } }  // namespace v8::internal