Implement API to disallow code generation from strings for a context.

include/v8.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 97 matching lines @@
 namespace internal {
 
 class Arguments;
 class Object;
 class Heap;
 class HeapObject;
 class Isolate;
 }
 
 
-// --- W e a k  H a n d l e s
+// --- Weak Handles ---
 
 
 /**
  * A weak reference callback function.
  *
  * This callback should either explicitly invoke Dispose on |object| if
  * V8 wrapper is not needed anymore, or 'revive' it by invocation of MakeWeak.
  *
  * \param object the weak global object to be reclaimed by the garbage collector
  * \param parameter the value passed in when making the weak global object
  */
 typedef void (*WeakReferenceCallback)(Persistent<Value> object,
                                       void* parameter);
 
 
-// --- H a n d l e s ---
+// --- Handles ---
 
 #define TYPE_CHECK(T, S)                                       \
   while (false) {                                              \
     *(static_cast<T* volatile*>(0)) = static_cast<S*>(0);      \
   }
 
 /**
  * An object reference managed by the v8 garbage collector.
  *
  * All objects returned from v8 have to be tracked by the garbage
@@ skipping 331 matching lines @@
 
   // Allow for the active closing of HandleScopes which allows to pass a handle
   // from the HandleScope being closed to the next top most HandleScope.
   bool is_closed_;
   internal::Object** RawClose(internal::Object** value);
 
   friend class ImplementationUtilities;
 };
 
 
-// --- S p e c i a l   o b j e c t s ---
+// --- Special objects ---
 
 
 /**
  * The superclass of values and API object templates.
  */
 class V8EXPORT Data {
  private:
   Data();
 };
 
@@ skipping 337 matching lines @@
   bool IsEval() const;
 
   /**
    * Returns whther or not the associated function is called as a
    * constructor via "new".
    */
   bool IsConstructor() const;
 };
 
 
-// --- V a l u e ---
+// --- Value ---
 
 
 /**
  * The superclass of all JavaScript values and objects.
  */
 class Value : public Data {
  public:
 
   /**
    * Returns true if this value is the undefined value.  See ECMA-262
@@ skipping 921 matching lines @@
   static inline External* Cast(Value* obj);
   V8EXPORT void* Value() const;
  private:
   V8EXPORT External();
   V8EXPORT static void CheckCast(v8::Value* obj);
   static inline void* QuickUnwrap(Handle<v8::Value> obj);
   V8EXPORT static void* FullUnwrap(Handle<v8::Value> obj);
 };
 
 
-// --- T e m p l a t e s ---
+// --- Templates ---
 
 
 /**
  * The superclass of object and function templates.
  */
 class V8EXPORT Template : public Data {
  public:
   /** Adds a property to each instance created by this template.*/
   void Set(Handle<String> name, Handle<Data> value,
            PropertyAttribute attributes = None);
@@ skipping 513 matching lines @@
 class V8EXPORT TypeSwitch : public Data {
  public:
   static Local<TypeSwitch> New(Handle<FunctionTemplate> type);
   static Local<TypeSwitch> New(int argc, Handle<FunctionTemplate> types[]);
   int match(Handle<Value> value);
  private:
   TypeSwitch();
 };
 
 
-// --- E x t e n s i o n s ---
+// --- Extensions ---
 
 
 /**
  * Ignore
  */
 class V8EXPORT Extension {  // NOLINT
  public:
   Extension(const char* name,
             const char* source = 0,
             int dep_count = 0,
@@ skipping 31 matching lines @@
  * Ignore
  */
 class V8EXPORT DeclareExtension {
  public:
   inline DeclareExtension(Extension* extension) {
     RegisterExtension(extension);
   }
 };
 
 
-// --- S t a t i c s ---
+// --- Statics ---
 
 
 Handle<Primitive> V8EXPORT Undefined();
 Handle<Primitive> V8EXPORT Null();
 Handle<Boolean> V8EXPORT True();
 Handle<Boolean> V8EXPORT False();
 
 
 /**
  * A set of constraints that specifies the limits of the runtime's memory use.
@@ skipping 20 matching lines @@
   int max_young_space_size_;
   int max_old_space_size_;
   int max_executable_size_;
   uint32_t* stack_limit_;
 };
 
 
 bool V8EXPORT SetResourceConstraints(ResourceConstraints* constraints);
 
 
-// --- E x c e p t i o n s ---
+// --- Exceptions ---
 
 
 typedef void (*FatalErrorCallback)(const char* location, const char* message);
 
 
 typedef void (*MessageCallback)(Handle<Message> message, Handle<Value> data);
 
 
 /**
  * Schedules an exception to be thrown when returning to JavaScript.  When an
@@ skipping 10 matching lines @@
 class V8EXPORT Exception {
  public:
   static Local<Value> RangeError(Handle<String> message);
   static Local<Value> ReferenceError(Handle<String> message);
   static Local<Value> SyntaxError(Handle<String> message);
   static Local<Value> TypeError(Handle<String> message);
   static Local<Value> Error(Handle<String> message);
 };
 
 
-// --- C o u n t e r s  C a l l b a c k s ---
+// --- Counters Callbacks ---
 
 typedef int* (*CounterLookupCallback)(const char* name);
 
 typedef void* (*CreateHistogramCallback)(const char* name,
                                          int min,
                                          int max,
                                          size_t buckets);
 
 typedef void (*AddHistogramSampleCallback)(void* histogram, int sample);
 
-// --- M e m o r y  A l l o c a t i o n   C a l l b a c k ---
+// --- Memory Allocation Callback ---
   enum ObjectSpace {
     kObjectSpaceNewSpace = 1 << 0,
     kObjectSpaceOldPointerSpace = 1 << 1,
     kObjectSpaceOldDataSpace = 1 << 2,
     kObjectSpaceCodeSpace = 1 << 3,
     kObjectSpaceMapSpace = 1 << 4,
     kObjectSpaceLoSpace = 1 << 5,
 
     kObjectSpaceAll = kObjectSpaceNewSpace | kObjectSpaceOldPointerSpace |
       kObjectSpaceOldDataSpace | kObjectSpaceCodeSpace | kObjectSpaceMapSpace |
       kObjectSpaceLoSpace
   };
 
   enum AllocationAction {
     kAllocationActionAllocate = 1 << 0,
     kAllocationActionFree = 1 << 1,
     kAllocationActionAll = kAllocationActionAllocate | kAllocationActionFree
   };
 
 typedef void (*MemoryAllocationCallback)(ObjectSpace space,
                                          AllocationAction action,
                                          int size);
 
-// --- F a i l e d A c c e s s C h e c k C a l l b a c k ---
+// --- Failed Access Check Callback ---
 typedef void (*FailedAccessCheckCallback)(Local<Object> target,
                                           AccessType type,
                                           Local<Value> data);
 
-// --- G a r b a g e C o l l e c t i o n  C a l l b a c k s
+// --- AllowCodeGenerationFromStrings callbacks ---
+
+/**
+ * Callback to check if code generation from strings is allowed. See
+ * Context::AllowCodeGenerationFromStrings.
+ */
+typedef bool (*AllowCodeGenerationFromStringsCallback)(Local<Context> context);
+
+// --- Garbage Collection Callbacks ---
 
 /**
  * Applications can register callback functions which will be called
  * before and after a garbage collection.  Allocations are not
  * allowed in the callback functions, you therefore cannot manipulate
  * objects (set or delete properties for example) since it is possible
  * such operations will result in the allocation of objects.
  */
 enum GCType {
   kGCTypeScavenge = 1 << 0,
@@ skipping 160 matching lines @@
 
 /**
  * Container class for static utility functions.
  */
 class V8EXPORT V8 {
  public:
   /** Set the callback to invoke in case of fatal errors. */
   static void SetFatalErrorHandler(FatalErrorCallback that);
 
   /**
+   * Set the callback to invoke to check if code generation from
+   * strings should be allowed.
+   */
+  static void SetAllowCodeGenerationFromStringsCallback(
+      AllowCodeGenerationFromStringsCallback that);
+
+  /**
    * Ignore out-of-memory exceptions.
    *
    * V8 running out of memory is treated as a fatal error by default.
    * This means that the fatal error handler is called and that V8 is
    * terminated.
    *
    * IgnoreOutOfMemoryException can be used to not treat a
    * out-of-memory situation as a fatal error.  This way, the contexts
    * that did not cause the out of memory problem might be able to
    * continue execution.
@@ skipping 507 matching lines @@
   void* message_;
   bool is_verbose_ : 1;
   bool can_continue_ : 1;
   bool capture_message_ : 1;
   bool rethrow_ : 1;
 
   friend class v8::internal::Isolate;
 };
 
 
-// --- C o n t e x t ---
+// --- Context ---
 
 
 /**
  * Ignore
  */
 class V8EXPORT ExtensionConfiguration {
  public:
   ExtensionConfiguration(int name_count, const char* names[])
       : name_count_(name_count), names_(names) { }
  private:
@@ skipping 115 matching lines @@
 
   /**
    * Associate an additional data object with the context. This is mainly used
    * with the debugger to provide additional information on the context through
    * the debugger API.
    */
   void SetData(Handle<String> data);
   Local<Value> GetData();
 
   /**
+   * Control whether code generation from strings is allowed. Calling
+   * this method with false will disable 'eval' and the 'Function'
+   * constructor for code running in this context. If 'eval' or the
+   * 'Function' constructor are used an exception will be thrown.
+   *
+   * If code generation from strings is not allowed the
+   * V8::AllowCodeGenerationFromStrings callback will be invoked if
+   * set before blocking the call to 'eval' or the 'Function'
+   * constructor. If that callback returns true, the call will be
+   * allowed, otherwise an exception will be thrown. If no callback is
+   * set an exception will be thrown.
+   */
+  void AllowCodeGenerationFromStrings(bool allow);
+
+  /**
    * Stack-allocated class which sets the execution context for all
    * operations executed within a local scope.
    */
   class Scope {
    public:
     explicit inline Scope(Handle<Context> context) : context_(context) {
       context_->Enter();
     }
     inline ~Scope() { context_->Exit(); }
    private:
@@ skipping 175 matching lines @@
   };
   virtual ~ActivityControl() {}
   /**
    * Notify about current progress. The activity can be stopped by
    * returning kAbort as the callback result.
    */
   virtual ControlOption ReportProgressValue(int done, int total) = 0;
 };
 
 
-// --- I m p l e m e n t a t i o n ---
+// --- Implementation ---
 
 
 namespace internal {
 
 static const int kApiPointerSize = sizeof(void*);  // NOLINT
 static const int kApiIntSize = sizeof(int);  // NOLINT
 
 // Tag information for HeapObject.
 const int kHeapObjectTag = 1;
 const int kHeapObjectTagSize = 2;
@@ skipping 491 matching lines @@
 
 
 }  // namespace v8
 
 
 #undef V8EXPORT
 #undef TYPE_CHECK
 
 
 #endif  // V8_H_