Removed some unsafe uses of StringShape....

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 765 matching lines @@
   // Call the slow part of scavenge object.
   return ScavengeObjectSlow(p, object);
 }
 
 
 static inline bool IsShortcutCandidate(HeapObject* object, Map* map) {
   // A ConsString object with Heap::empty_string() as the right side
   // is a candidate for being shortcut by the scavenger.
   ASSERT(object->map() == map);
   if (map->instance_type() >= FIRST_NONSTRING_TYPE) return false;
-  StringShape shape(map);
-  return (shape.representation_tag() == kConsStringTag) &&
+  return (StringShape(map).representation_tag() == kConsStringTag) &&
          (ConsString::cast(object)->unchecked_second() == Heap::empty_string());
 }
 
 
 void Heap::ScavengeObjectSlow(HeapObject** p, HeapObject* object) {
   ASSERT(InFromSpace(object));
   MapWord first_word = object->map_word();
   ASSERT(!first_word.IsForwardingAddress());
 
   // Optimization: Bypass flattened ConsString objects.
@@ skipping 542 matching lines @@
   share->set_function_data(undefined_value());
   share->set_lazy_load_data(undefined_value());
   share->set_script(undefined_value());
   share->set_start_position_and_type(0);
   share->set_debug_info(undefined_value());
   return result;
 }
 
 
 Object* Heap::AllocateConsString(String* first,
-                                 StringShape first_shape,
-                                 String* second,
-                                 StringShape second_shape) {
+                                 String* second) {
+  StringShape first_shape(first);
+  StringShape second_shape(second);
   int first_length = first->length(first_shape);
   int second_length = second->length(second_shape);
   int length = first_length + second_length;
   bool is_ascii = first_shape.IsAsciiRepresentation()
       && second_shape.IsAsciiRepresentation();
 
   // If the resulting string is small make a flat string.
   if (length < String::kMinNonFlatLength) {
     ASSERT(first->IsFlat(first_shape));
     ASSERT(second->IsFlat(second_shape));
@@ skipping 41 matching lines @@
   ASSERT(InNewSpace(result));
   ConsString* cons_string = ConsString::cast(result);
   cons_string->set_first(first, SKIP_WRITE_BARRIER);
   cons_string->set_second(second, SKIP_WRITE_BARRIER);
   cons_string->set_length(length);
   return result;
 }
 
 
 Object* Heap::AllocateSlicedString(String* buffer,
-                                   StringShape buffer_shape,
                                    int start,
                                    int end) {
+  StringShape buffer_shape(buffer);
   int length = end - start;
 
   // If the resulting string is small make a sub string.
   if (end - start <= String::kMinNonFlatLength) {
     return Heap::AllocateSubString(buffer, buffer_shape, start, end);
   }
 
   Map* map;
   if (length <= String::kMaxShortStringSize) {
     map = buffer_shape.IsAsciiRepresentation() ?
@@ skipping 1825 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