Extension state made per-siolate in genesis

src/api.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 12 matching lines @@
 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 #ifndef V8_API_H_
 #define V8_API_H_
 
 #include "apiutils.h"
 #include "factory.h"
+#include "hashmap.h"
 
 #include "../include/v8-testing.h"
 
 namespace v8 {
 
 // Constants used in the implementation of the API.  The most natural thing
 // would usually be to place these with the classes that use them, but
 // we want to keep them out of v8.h because it is an externally
 // visible file.
 class Consts {
@@ skipping 87 matching lines @@
 
 class ApiFunction {
  public:
   explicit ApiFunction(v8::internal::Address addr) : addr_(addr) { }
   v8::internal::Address address() { return addr_; }
  private:
   v8::internal::Address addr_;
 };
 
 
-enum ExtensionTraversalState {
-  UNVISITED, VISITED, INSTALLED
-};
-
 
 class RegisteredExtension {
  public:
   explicit RegisteredExtension(Extension* extension);
   static void Register(RegisteredExtension* that);
   Extension* extension() { return extension_; }
   RegisteredExtension* next() { return next_; }
   RegisteredExtension* next_auto() { return next_auto_; }
-  ExtensionTraversalState state() { return state_; }
-  void set_state(ExtensionTraversalState value) { state_ = value; }
   static RegisteredExtension* first_extension() { return first_extension_; }
  private:
   Extension* extension_;
   RegisteredExtension* next_;
   RegisteredExtension* next_auto_;
-  ExtensionTraversalState state_;
   static RegisteredExtension* first_extension_;
 };
 
 
+namespace internal {
+enum ExtensionTraversalState {
+  UNVISITED, VISITED, INSTALLED
+};
+
+
+class ExtensionStates : private HashMap {

[Vitaly Repeshko, 2011/11/15 18:14:17]

Use delegation instead of implementation inheritance.

+ public:
+  ExtensionStates();
+  ExtensionTraversalState get_state(RegisteredExtension* extension);
+  void set_state(RegisteredExtension* extension, ExtensionTraversalState state);
+};
+}

[Vitaly Repeshko, 2011/11/15 18:14:17]

nit:  // namespace internal

+
+
 class Utils {
  public:
   static bool ReportApiFailure(const char* location, const char* message);
 
   static Local<FunctionTemplate> ToFunctionTemplate(NeanderObject obj);
   static Local<ObjectTemplate> ToObjectTemplate(NeanderObject obj);
 
   static inline Local<Context> ToLocal(
       v8::internal::Handle<v8::internal::Context> obj);
   static inline Local<Value> ToLocal(
@@ skipping 388 matching lines @@
     stress_type_ = stress_type;
   }
 
  private:
   static v8::Testing::StressType stress_type_;
 };
 
 } }  // namespace v8::internal
 
 #endif  // V8_API_H_