Rename SmartPointer to SmartArrayPointer.

src/liveobjectlist.cc

 // Copyright 2011 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 166 matching lines @@
   FOR_EACH_LIVE_OBJECT_TYPE(CHECK_OBJECT_TYPE)
 #undef CHECK_OBJECT_TYPE
 
   return false;
 }
 
 
 const AllocationSpace kInvalidSpace = static_cast<AllocationSpace>(-1);
 
 static AllocationSpace FindSpaceFor(String* space_str) {
-  SmartPointer<char> s =
+  SmartArrayPointer<char> s =
       space_str->ToCString(DISALLOW_NULLS, ROBUST_STRING_TRAVERSAL);
 
   const char* key_str = *s;
   switch (key_str[0]) {
     case 'c':
       if (strcmp(key_str, "cell") == 0) return CELL_SPACE;
       if (strcmp(key_str, "code") == 0) return CODE_SPACE;
       break;
     case 'l':
       if (strcmp(key_str, "lo") == 0) return LO_SPACE;
@@ skipping 31 matching lines @@
     if (heap->InSpace(heap_obj, static_cast<AllocationSpace>(sp))) {
       return false;
     }
   }
   SLOW_ASSERT(heap->InSpace(heap_obj, LO_SPACE));
   return true;
 }
 
 
 static LiveObjectType FindTypeFor(String* type_str) {
-  SmartPointer<char> s =
+  SmartArrayPointer<char> s =
       type_str->ToCString(DISALLOW_NULLS, ROBUST_STRING_TRAVERSAL);
 
 #define CHECK_OBJECT_TYPE(type_, name) { \
     const char* type_desc = GetObjectTypeDesc(kType##type_); \
     const char* key_str = *s; \
     if (strstr(type_desc, key_str) != NULL) return kType##type_; \
   }
   FOR_EACH_LIVE_OBJECT_TYPE(CHECK_OBJECT_TYPE)
 #undef CHECK_OBJECT_TYPE
 
@@ skipping 246 matching lines @@
                  reinterpret_cast<void*>(obj),
                  GetObjectTypeDesc(obj),
                  length);
 
   } else if (obj->IsString()) {
     String *str = String::cast(obj);
     // Only grab up to 160 chars in case they are double byte.
     // We'll only dump 80 of them after we compact them.
     const int kMaxCharToDump = 80;
     const int kMaxBufferSize = kMaxCharToDump * 2;
-    SmartPointer<char> str_sp = str->ToCString(DISALLOW_NULLS,
-                                               ROBUST_STRING_TRAVERSAL,
-                                               0,
-                                               kMaxBufferSize);
+    SmartArrayPointer<char> str_sp = str->ToCString(DISALLOW_NULLS,
+                                                    ROBUST_STRING_TRAVERSAL,
+                                                    0,
+                                                    kMaxBufferSize);
     char* str_cstr = *str_sp;
     int length = CompactString(str_cstr);
     OS::SNPrintF(buffer_v,
                  "%p <%s> '%.80s%s'",
                  reinterpret_cast<void*>(obj),
                  GetObjectTypeDesc(obj),
                  str_cstr,
                  (length > kMaxCharToDump) ? "..." : "");
 
   } else if (obj->IsJSFunction() || obj->IsSharedFunctionInfo()) {
     SharedFunctionInfo* sinfo;
     if (obj->IsJSFunction()) {
       JSFunction* func = JSFunction::cast(obj);
       sinfo = func->shared();
     } else {
       sinfo = SharedFunctionInfo::cast(obj);
     }
 
     String* name = sinfo->DebugName();
-    SmartPointer<char> name_sp =
+    SmartArrayPointer<char> name_sp =
         name->ToCString(DISALLOW_NULLS, ROBUST_STRING_TRAVERSAL);
     char* name_cstr = *name_sp;
 
     HeapStringAllocator string_allocator;
     StringStream stream(&string_allocator);
     sinfo->SourceCodePrint(&stream, 50);
-    SmartPointer<const char> source_sp = stream.ToCString();
+    SmartArrayPointer<const char> source_sp = stream.ToCString();
     const char* source_cstr = *source_sp;
 
     OS::SNPrintF(buffer_v,
                  "%p <%s> '%s' %s",
                  reinterpret_cast<void*>(obj),
                  GetObjectTypeDesc(obj),
                  name_cstr,
                  source_cstr);
 
   } else if (obj->IsFixedArray()) {
@@ skipping 1102 matching lines @@
   Element* element = FindElementFor<HeapObject*>(GetElementObj, hobj);
   if (element != NULL) {
     return element->id_;
   }
   return 0;  // Invalid address.
 }
 
 
 // Gets the obj id for the specified address if valid.
 Object* LiveObjectList::GetObjId(Handle<String> address) {
-  SmartPointer<char> addr_str =
+  SmartArrayPointer<char> addr_str =
       address->ToCString(DISALLOW_NULLS, ROBUST_STRING_TRAVERSAL);
 
   Isolate* isolate = Isolate::Current();
 
   // Extract the address value from the string.
   int value =
       static_cast<int>(StringToInt(isolate->unicode_cache(), *address, 16));
   Object* obj = reinterpret_cast<Object*>(value);
   return Smi::FromInt(GetObjId(obj));
 }
@@ skipping 946 matching lines @@
                 i++, heap_obj, heap->new_space()->FromSpaceLow());
     }
   }
 }
 #endif  // VERIFY_LOL
 
 
 } }  // namespace v8::internal
 
 #endif  // LIVE_OBJECT_LIST