Removed some unsafe uses of StringShape....

test/cctest/test-strings.cc

 // Copyright 2006-2008 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 197 matching lines @@
 static void TraverseFirst(Handle<String> s1, Handle<String> s2, int chars) {
   int i = 0;
   buffer.Reset(*s1);
   StringInputBuffer buffer2(*s2);
   while (buffer.has_more() && i < chars) {
     CHECK(buffer2.has_more());
     uint16_t c = buffer.GetNext();
     CHECK_EQ(c, buffer2.GetNext());
     i++;
   }
-  StringShape shape1(*s1);
-  StringShape shape2(*s2);
-  s1->Get(shape1, s1->length(shape1) - 1);
-  s2->Get(shape2, s2->length(shape2) - 1);
+  s1->Get(StringShape(*s1), s1->length() - 1);
+  s2->Get(StringShape(*s2), s2->length() - 1);
 }
 
 
 TEST(Traverse) {
   printf("TestTraverse\n");
   InitializeVM();
   v8::HandleScope scope;
   Handle<String> building_blocks[NUMBER_OF_BUILDING_BLOCKS];
   InitializeBuildingBlocks(building_blocks);
   Handle<String> flat = ConstructBalanced(building_blocks);
@@ skipping 12 matching lines @@
       ConstructLeft(building_blocks, SUPER_DEEP_DEPTH);
   Handle<String> right_deep_asymmetric =
       ConstructRight(building_blocks, SUPER_DEEP_DEPTH);
   printf("5\n");
   TraverseFirst(left_asymmetric, left_deep_asymmetric, 1050);
   printf("6\n");
   TraverseFirst(left_asymmetric, right_deep_asymmetric, 65536);
   printf("7\n");
   Handle<String> right_deep_slice =
       Factory::NewStringSlice(left_deep_asymmetric,
-                              StringShape(*left_deep_asymmetric),
                               left_deep_asymmetric->length() - 1050,
                               left_deep_asymmetric->length() - 50);
   Handle<String> left_deep_slice =
       Factory::NewStringSlice(right_deep_asymmetric,
-                              StringShape(*right_deep_asymmetric),
                               right_deep_asymmetric->length() - 1050,
                               right_deep_asymmetric->length() - 50);
   printf("8\n");
   Traverse(right_deep_slice, left_deep_slice);
   printf("9\n");
   FlattenString(left_asymmetric);
   printf("10\n");
   Traverse(flat, left_asymmetric);
   printf("11\n");
   FlattenString(right_asymmetric);
   printf("12\n");
   Traverse(flat, right_asymmetric);
   printf("14\n");
   FlattenString(symmetric);
   printf("15\n");
   Traverse(flat, symmetric);
   printf("16\n");
   FlattenString(left_deep_asymmetric);
   printf("18\n");
 }
 
 
 static Handle<String> SliceOf(Handle<String> underlying) {
   int start = gen() % underlying->length();
   int end = start + gen() % (underlying->length() - start);
   return Factory::NewStringSlice(underlying,
-                                 StringShape(*underlying),
                                  start,
                                  end);
 }
 
 
 static Handle<String> ConstructSliceTree(
     Handle<String> building_blocks[NUMBER_OF_BUILDING_BLOCKS],
     int from,
     int to) {
   ASSERT(to > from);
@@ skipping 107 matching lines @@
     int written = mixed->WriteUtf8(buffer, i);
     CHECK_EQ(lengths[i], written);
     // Check that the contents are correct
     for (int j = 0; j < lengths[i]; j++)
       CHECK_EQ(as_utf8[j], static_cast<unsigned char>(buffer[j]));
     // Check that the rest of the buffer hasn't been touched
     for (int j = lengths[i]; j < 11; j++)
       CHECK_EQ(kNoChar, buffer[j]);
   }
 }