abstract eternal into class

src/global-handles.h

 // 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 378 matching lines @@
     I18N_TEMPLATE_TWO,
 
     NUMBER_OF_SINGLETON_HANDLES
   };
 
   EternalHandles();
   ~EternalHandles();
 
   int NumberOfHandles() { return size_; }
 
-  // Create an EternalHandle, returning the index.
-  int Create(Isolate* isolate, Object* object);
+  // Create an EternalHandle, overwriting the index.
+  void Create(Isolate* isolate, Object* object, int* index);

[rossberg, 2013/08/12 15:13:13]

Same here.

 
   // Grab the handle for an existing EternalHandle.
   inline Handle<Object> Get(int index) {
     return Handle<Object>(GetLocation(index));
   }
 
   // Grab the handle for an existing SingletonHandle.
   inline Handle<Object> GetSingleton(SingletonHandle singleton) {
     ASSERT(Exists(singleton));
     return Get(singleton_handles_[singleton]);
   }
 
   // Checks whether a SingletonHandle has been assigned.
   inline bool Exists(SingletonHandle singleton) {
     return singleton_handles_[singleton] != kInvalidIndex;
   }
 
   // Assign a SingletonHandle to an empty slot and returns the handle.
   Handle<Object> CreateSingleton(Isolate* isolate,
                                  Object* object,
                                  SingletonHandle singleton) {
-    ASSERT(singleton_handles_[singleton] == kInvalidIndex);
-    singleton_handles_[singleton] = Create(isolate, object);
+    Create(isolate, object, &singleton_handles_[singleton]);
     return Get(singleton_handles_[singleton]);
   }
 
   // Iterates over all handles.
   void IterateAllRoots(ObjectVisitor* visitor);
   // Iterates over all handles which might be in new space.
   void IterateNewSpaceRoots(ObjectVisitor* visitor);
   // Rebuilds new space list.
   void PostGarbageCollectionProcessing(Heap* heap);
 
@@ skipping 14 matching lines @@
   List<int> new_space_indices_;
   int singleton_handles_[NUMBER_OF_SINGLETON_HANDLES];
 
   DISALLOW_COPY_AND_ASSIGN(EternalHandles);
 };
 
 
 } }  // namespace v8::internal
 
 #endif  // V8_GLOBAL_HANDLES_H_