1 // Copyright 2013 The Chromium Authors. All rights reserved. 2 // Use of this source code is governed by a BSD-style license that can be 3 // found in the LICENSE file. 4 5 #ifndef GIN_PER_ISOLATE_DATA_H_ 6 #define GIN_PER_ISOLATE_DATA_H_ 7 8 #include <map> 9 10 #include "base/basictypes.h" 11 #include "base/memory/ref_counted.h" 12 #include "gin/gin_export.h" 13 #include "gin/public/wrapper_info.h" 14 #include "v8/include/v8.h" 15 16 namespace base { 17 class MessageLoopProxy; 18 } 19 20 namespace gin { 21 22 class IndexedPropertyInterceptor; 23 class NamedPropertyInterceptor; 24 class WrappableBase; 25 26 // There is one instance of PerIsolateData per v8::Isolate managed by Gin. This 27 // class stores all the Gin-related data that varies per isolate. 28 class GIN_EXPORT PerIsolateData { 29 public: 30 PerIsolateData(v8::Isolate* isolate, v8::ArrayBuffer::Allocator* allocator); 31 ~PerIsolateData(); 32 33 static PerIsolateData* From(v8::Isolate* isolate); 34 35 // Each isolate is associated with a collection of v8::ObjectTemplates and 36 // v8::FunctionTemplates. Typically these template objects are created 37 // lazily. 38 void SetObjectTemplate(WrapperInfo* info, 39 v8::Local<v8::ObjectTemplate> object_template); 40 void SetFunctionTemplate(WrapperInfo* info, 41 v8::Local<v8::FunctionTemplate> function_template); 42 43 // These are low-level functions for retrieving object or function templates 44 // stored in this object. Because these templates are often created lazily, 45 // most clients should call higher-level functions that know how to populate 46 // these templates if they haven't already been created. 47 v8::Local<v8::ObjectTemplate> GetObjectTemplate(WrapperInfo* info); 48 v8::Local<v8::FunctionTemplate> GetFunctionTemplate(WrapperInfo* info); 49 50 // We maintain a map from Wrappable objects that derive from one of the 51 // interceptor interfaces to the interceptor interface pointers. 52 void SetIndexedPropertyInterceptor(WrappableBase* base, 53 IndexedPropertyInterceptor* interceptor); 54 void SetNamedPropertyInterceptor(WrappableBase* base, 55 NamedPropertyInterceptor* interceptor); 56 57 void ClearIndexedPropertyInterceptor(WrappableBase* base, 58 IndexedPropertyInterceptor* interceptor); 59 void ClearNamedPropertyInterceptor(WrappableBase* base, 60 NamedPropertyInterceptor* interceptor); 61 62 IndexedPropertyInterceptor* GetIndexedPropertyInterceptor( 63 WrappableBase* base); 64 NamedPropertyInterceptor* GetNamedPropertyInterceptor(WrappableBase* base); 65 isolate()66 v8::Isolate* isolate() { return isolate_; } allocator()67 v8::ArrayBuffer::Allocator* allocator() { return allocator_; } message_loop_proxy()68 base::MessageLoopProxy* message_loop_proxy() { 69 return message_loop_proxy_.get(); 70 } 71 72 private: 73 typedef std::map< 74 WrapperInfo*, v8::Eternal<v8::ObjectTemplate> > ObjectTemplateMap; 75 typedef std::map< 76 WrapperInfo*, v8::Eternal<v8::FunctionTemplate> > FunctionTemplateMap; 77 typedef std::map<WrappableBase*, IndexedPropertyInterceptor*> 78 IndexedPropertyInterceptorMap; 79 typedef std::map<WrappableBase*, NamedPropertyInterceptor*> 80 NamedPropertyInterceptorMap; 81 82 // PerIsolateData doesn't actually own |isolate_|. Instead, the isolate is 83 // owned by the IsolateHolder, which also owns the PerIsolateData. 84 v8::Isolate* isolate_; 85 v8::ArrayBuffer::Allocator* allocator_; 86 ObjectTemplateMap object_templates_; 87 FunctionTemplateMap function_templates_; 88 IndexedPropertyInterceptorMap indexed_interceptors_; 89 NamedPropertyInterceptorMap named_interceptors_; 90 scoped_refptr<base::MessageLoopProxy> message_loop_proxy_; 91 92 DISALLOW_COPY_AND_ASSIGN(PerIsolateData); 93 }; 94 95 } // namespace gin 96 97 #endif // GIN_PER_ISOLATE_DATA_H_ 98