Replace the use CharacterStreams in Heap::AllocateSymbolInternal and String::ComputeHash

test/cctest/test-strings.cc

 // Copyright 2012 the V8 project authors. All rights reserved.
 
 // Check that we can traverse very deep stacks of ConsStrings using
 // StringInputBuffer.  Check that Get(int) works on very deep stacks
 // of ConsStrings.  These operations may not be very fast, but they
 // should be possible without getting errors due to too deep recursion.
 
 #include <stdlib.h>
 
 #include "v8.h"
@@ skipping 327 matching lines @@
   if (cons_string->IsConsString()) {
     return AccumulateStats(ConsString::cast(*cons_string), stats);
   }
   // This string got flattened by gc.
   stats->chars_ += cons_string->length();
 }
 
 
 void AccumulateStatsWithOperator(
     ConsString* cons_string, ConsStringStats* stats) {
-  // Init op.
+  unsigned offset = 0;
+  int32_t type = cons_string->map()->instance_type();
+  unsigned length = static_cast<unsigned>(cons_string->length());
   ConsStringIteratorOp op;
-  op.Reset();
-  // Use response for initial search and on blown stack.
-  ConsStringIteratorOp::ContinueResponse response;
-  response.string_ = cons_string;
-  response.offset_ = 0;
-  response.type_ = cons_string->map()->instance_type();
-  response.length_ = (uint32_t) cons_string->length();
+  String* string = op.Operate(cons_string, &offset, &type, &length);
+  CHECK(string != NULL);
   while (true) {
-    String* string = op.Operate(ConsString::cast(response.string_),
-                                &response.offset_,
-                                &response.type_,
-                                &response.length_);
-    CHECK(string != NULL);
-    while (true) {
-      // Accumulate stats.
-      stats->leaves_++;
-      stats->chars_ += string->length();
-      // Check for completion.
-      bool keep_going_fast_check = op.HasMore();
-      bool keep_going = op.ContinueOperation(&response);
-      if (!keep_going) return;
-      // Verify no false positives for fast check.
-      CHECK(keep_going_fast_check);
-      CHECK(response.string_ != NULL);
-      // Blew stack. Restart outer loop.
-      if (response.string_->IsConsString()) break;
-      string = response.string_;
-    }
-  };
+    ASSERT(!string->IsConsString());
+    // Accumulate stats.
+    stats->leaves_++;
+    stats->chars_ += string->length();
+    // Check for completion.
+    bool keep_going_fast_check = op.HasMore();
+    string = op.ContinueOperation(&type, &length);
+    if (string == NULL) return;
+    // Verify no false positives for fast check.
+    CHECK(keep_going_fast_check);
+  }
 }
 
 
 void VerifyConsString(Handle<String> root, ConsStringGenerationData* data) {
   // Verify basic data.
   CHECK(root->IsConsString());
   CHECK((unsigned)root->length() == data->stats_.chars_);
   // Recursive verify.
   ConsStringStats stats;
   AccumulateStats(ConsString::cast(*root), &stats);
@@ skipping 905 matching lines @@
 
   v8::Local<v8::String> expected = v8_str("ascii\x80only\x80string\x80");
   CHECK(expected->Equals(result));
 }
 
 
 TEST(IsAscii) {
   CHECK(String::IsAscii(static_cast<char*>(NULL), 0));
   CHECK(String::IsAscii(static_cast<uc16*>(NULL), 0));
 }