Version 3.20.15

include/v8.h

 // Copyright 2012 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 22 matching lines @@
  * V8 header file, include/v8.h.
  *
  * For other documentation see http://code.google.com/apis/v8/
  */
 
 #ifndef V8_H_
 #define V8_H_
 
 #include "v8stdint.h"
 
-// We reserve the V8_* prefix for macros defined in V8 public API and
-// assume there are no name conflicts with the embedder's code.
-
 #ifdef _WIN32
 
 // Setup for Windows DLL export/import. When building the V8 DLL the
 // BUILDING_V8_SHARED needs to be defined. When building a program which uses
 // the V8 DLL USING_V8_SHARED needs to be defined. When either building the V8
 // static library or building a program which uses the V8 static library neither
 // BUILDING_V8_SHARED nor USING_V8_SHARED should be defined.
 #if defined(BUILDING_V8_SHARED) && defined(USING_V8_SHARED)
 #error both BUILDING_V8_SHARED and USING_V8_SHARED are set - please check the\
   build configuration to ensure that at most one of these is set
 #endif
 
 #ifdef BUILDING_V8_SHARED
-#define V8_EXPORT __declspec(dllexport)
+#define V8EXPORT __declspec(dllexport)
 #elif USING_V8_SHARED
-#define V8_EXPORT __declspec(dllimport)
+#define V8EXPORT __declspec(dllimport)
 #else
-#define V8_EXPORT
+#define V8EXPORT
 #endif  // BUILDING_V8_SHARED
 
 #else  // _WIN32
 
 // Setup for Linux shared library export.
 #if defined(__GNUC__) && ((__GNUC__ >= 4) || \
     (__GNUC__ == 3 && __GNUC_MINOR__ >= 3)) && defined(V8_SHARED)
 #ifdef BUILDING_V8_SHARED
-#define V8_EXPORT __attribute__ ((visibility("default")))
+#define V8EXPORT __attribute__ ((visibility("default")))
 #else
-#define V8_EXPORT
+#define V8EXPORT
 #endif
 #else
-#define V8_EXPORT
+#define V8EXPORT
 #endif
 
 #endif  // _WIN32
 
 #if defined(__GNUC__) && !defined(DEBUG)
 #define V8_INLINE(declarator) inline __attribute__((always_inline)) declarator
 #elif defined(_MSC_VER) && !defined(DEBUG)
 #define V8_INLINE(declarator) __forceinline declarator
 #else
 #define V8_INLINE(declarator) inline declarator
@@ skipping 293 matching lines @@
   friend class HandleScope;
 
 #ifndef V8_USE_UNSAFE_HANDLES
   V8_INLINE(static Handle<T> New(Isolate* isolate, T* that));
 #endif
 
   T* val_;
 };
 
 
-// A value which will never be returned by Local::Eternalize
-// Useful for static initialization
-const int kUninitializedEternalIndex = -1;
-
-
 /**
  * A light-weight stack-allocated object handle.  All operations
  * that return objects from within v8 return them in local handles.  They
  * are created within HandleScopes, and all local handles allocated within a
  * handle scope are destroyed when the handle scope is destroyed.  Hence it
  * is not necessary to explicitly deallocate local handles.
  */
 // TODO(dcarney): deprecate entire class
 template <class T> class Local : public Handle<T> {
  public:
@@ skipping 25 matching lines @@
   template <class S> V8_INLINE(Local(Handle<S> that))
       : Handle<T>(reinterpret_cast<T*>(*that)) {
     TYPE_CHECK(T, S);
   }
 #endif
 
   template <class S> V8_INLINE(Local<S> As()) {
     return Local<S>::Cast(*this);
   }
 
-  // Keep this Local alive for the lifetime of the Isolate.
-  // It remains retrievable via the returned index,
-  V8_INLINE(int Eternalize(Isolate* isolate));
-  V8_INLINE(static Local<T> GetEternal(Isolate* isolate, int index));
-
   /**
    * Create a local handle for the content of another handle.
    * The referee is kept alive by the local handle even when
    * the original handle is destroyed/disposed.
    */
   V8_INLINE(static Local<T> New(Handle<T> that));
   V8_INLINE(static Local<T> New(Isolate* isolate, Handle<T> that));
 #ifndef V8_USE_UNSAFE_HANDLES
   // TODO(dcarney): remove before cutover
   V8_INLINE(static Local<T> New(Isolate* isolate, const Persistent<T>& that));
@@ skipping 351 matching lines @@
  * deleted or another handle scope is created.  If there is already a
  * handle scope and a new one is created, all allocations will take
  * place in the new handle scope until it is deleted.  After that,
  * new handles will again be allocated in the original handle scope.
  *
  * After the handle scope of a local handle has been deleted the
  * garbage collector will no longer track the object stored in the
  * handle and may deallocate it.  The behavior of accessing a handle
  * for which the handle scope has been deleted is undefined.
  */
-class V8_EXPORT HandleScope {
+class V8EXPORT HandleScope {
  public:
   // TODO(svenpanne) Deprecate me when Chrome is fixed!
   HandleScope();
 
   HandleScope(Isolate* isolate);
 
   ~HandleScope();
 
   /**
    * Closes the handle scope and returns the value as a handle in the
@@ skipping 18 matching lines @@
  private:
   // Make it hard to create heap-allocated or illegal handle scopes by
   // disallowing certain operations.
   HandleScope(const HandleScope&);
   void operator=(const HandleScope&);
   void* operator new(size_t size);
   void operator delete(void*, size_t);
 
   // This Data class is accessible internally as HandleScopeData through a
   // typedef in the ImplementationUtilities class.
-  class V8_EXPORT Data {
+  class V8EXPORT Data {
    public:
     internal::Object** next;
     internal::Object** limit;
     int level;
     V8_INLINE(void Initialize()) {
       next = limit = NULL;
       level = 0;
     }
   };
 
@@ skipping 12 matching lines @@
   friend class ImplementationUtilities;
 };
 
 
 // --- Special objects ---
 
 
 /**
  * The superclass of values and API object templates.
  */
-class V8_EXPORT Data {
+class V8EXPORT Data {
  private:
   Data();
 };
 
 
 /**
  * Pre-compilation data that can be associated with a script.  This
  * data can be calculated for a script in advance of actually
  * compiling it, and can be stored between compilations.  When script
  * data is given to the compile method compilation will be faster.
  */
-class V8_EXPORT ScriptData {  // NOLINT
+class V8EXPORT ScriptData {  // NOLINT
  public:
   virtual ~ScriptData() { }
 
   /**
    * Pre-compiles the specified script (context-independent).
    *
    * \param input Pointer to UTF-8 script source code.
    * \param length Length of UTF-8 script source code.
    */
   static ScriptData* PreCompile(const char* input, int length);
@@ skipping 57 matching lines @@
   Handle<Value> resource_name_;
   Handle<Integer> resource_line_offset_;
   Handle<Integer> resource_column_offset_;
   Handle<Boolean> resource_is_shared_cross_origin_;
 };
 
 
 /**
  * A compiled JavaScript script.
  */
-class V8_EXPORT Script {
+class V8EXPORT Script {
  public:
   /**
    * Compiles the specified script (context-independent).
    *
    * \param source Script source code.
    * \param origin Script origin, owned by caller, no references are kept
    *   when New() returns
    * \param pre_data Pre-parsing data, as obtained by ScriptData::PreCompile()
    *   using pre_data speeds compilation if it's done multiple times.
    *   Owned by caller, no references are kept when New() returns.
@@ skipping 97 matching lines @@
    */
   int GetLineNumber(int code_pos);
 
   static const int kNoScriptId = 0;
 };
 
 
 /**
  * An error message.
  */
-class V8_EXPORT Message {
+class V8EXPORT Message {
  public:
   Local<String> Get() const;
   Local<String> GetSourceLine() const;
 
   /**
    * Returns the resource name for the script from where the function causing
    * the error originates.
    */
   Handle<Value> GetScriptResourceName() const;
 
@@ skipping 51 matching lines @@
   static const int kNoLineNumberInfo = 0;
   static const int kNoColumnInfo = 0;
 };
 
 
 /**
  * Representation of a JavaScript stack trace. The information collected is a
  * snapshot of the execution stack and the information remains valid after
  * execution continues.
  */
-class V8_EXPORT StackTrace {
+class V8EXPORT StackTrace {
  public:
   /**
    * Flags that determine what information is placed captured for each
    * StackFrame when grabbing the current stack trace.
    */
   enum StackTraceOptions {
     kLineNumber = 1,
     kColumnOffset = 1 << 1 | kLineNumber,
     kScriptName = 1 << 2,
     kFunctionName = 1 << 3,
@@ skipping 28 matching lines @@
    */
   static Local<StackTrace> CurrentStackTrace(
       int frame_limit,
       StackTraceOptions options = kOverview);
 };
 
 
 /**
  * A single JavaScript stack frame.
  */
-class V8_EXPORT StackFrame {
+class V8EXPORT StackFrame {
  public:
   /**
    * Returns the number, 1-based, of the line for the associate function call.
    * This method will return Message::kNoLineNumberInfo if it is unable to
    * retrieve the line number, or if kLineNumber was not passed as an option
    * when capturing the StackTrace.
    */
   int GetLineNumber() const;
 
   /**
@@ skipping 31 matching lines @@
   bool IsEval() const;
 
   /**
    * Returns whether or not the associated function is called as a
    * constructor via "new".
    */
   bool IsConstructor() const;
 };
 
 
-/**
- * A JSON Parser.
- */
-class V8_EXPORT JSON {
- public:
-  /**
-   * Tries to parse the string |json_string| and returns it as object if
-   * successful.
-   *
-   * \param json_string The string to parse.
-   * \return The corresponding object if successfully parsed.
-   */
-  static Local<Object> Parse(Local<String> json_string);
-};
-
-
 // --- Value ---
 
 
 /**
  * The superclass of all JavaScript values and objects.
  */
-class V8_EXPORT Value : public Data {
+class V8EXPORT Value : public Data {
  public:
   /**
    * Returns true if this value is the undefined value.  See ECMA-262
    * 4.3.10.
    */
   V8_INLINE(bool IsUndefined() const);
 
   /**
    * Returns true if this value is the null value.  See ECMA-262
    * 4.3.11.
@@ skipping 210 matching lines @@
   V8_INLINE(bool QuickIsString() const);
   bool FullIsUndefined() const;
   bool FullIsNull() const;
   bool FullIsString() const;
 };
 
 
 /**
  * The superclass of primitive values.  See ECMA-262 4.3.2.
  */
-class V8_EXPORT Primitive : public Value { };
+class V8EXPORT Primitive : public Value { };
 
 
 /**
  * A primitive boolean value (ECMA-262, 4.3.14).  Either the true
  * or false value.
  */
-class V8_EXPORT Boolean : public Primitive {
+class V8EXPORT Boolean : public Primitive {
  public:
   bool Value() const;
   V8_INLINE(static Handle<Boolean> New(bool value));
 };
 
 
 /**
  * A JavaScript string value (ECMA-262, 4.3.17).
  */
-class V8_EXPORT String : public Primitive {
+class V8EXPORT String : public Primitive {
  public:
   enum Encoding {
     UNKNOWN_ENCODING = 0x1,
     TWO_BYTE_ENCODING = 0x0,
     ASCII_ENCODING = 0x4,
     ONE_BYTE_ENCODING = 0x4
   };
   /**
    * Returns the number of characters in this string.
    */
@@ skipping 85 matching lines @@
   /**
    * Returns true if the string is external
    */
   bool IsExternal() const;
 
   /**
    * Returns true if the string is both external and ASCII
    */
   bool IsExternalAscii() const;
 
-  class V8_EXPORT ExternalStringResourceBase {  // NOLINT
+  class V8EXPORT ExternalStringResourceBase {  // NOLINT
    public:
     virtual ~ExternalStringResourceBase() {}
 
    protected:
     ExternalStringResourceBase() {}
 
     /**
      * Internally V8 will call this Dispose method when the external string
      * resource is no longer needed. The default implementation will use the
      * delete operator. This method can be overridden in subclasses to
      * control how allocated external string resources are disposed.
      */
     virtual void Dispose() { delete this; }
 
    private:
     // Disallow copying and assigning.
     ExternalStringResourceBase(const ExternalStringResourceBase&);
     void operator=(const ExternalStringResourceBase&);
 
     friend class v8::internal::Heap;
   };
 
   /**
    * An ExternalStringResource is a wrapper around a two-byte string
    * buffer that resides outside V8's heap. Implement an
    * ExternalStringResource to manage the life cycle of the underlying
    * buffer.  Note that the string data must be immutable.
    */
-  class V8_EXPORT ExternalStringResource
+  class V8EXPORT ExternalStringResource
       : public ExternalStringResourceBase {
    public:
     /**
      * Override the destructor to manage the life cycle of the underlying
      * buffer.
      */
     virtual ~ExternalStringResource() {}
 
     /**
      * The string data from the underlying buffer.
@@ skipping 13 matching lines @@
    * An ExternalAsciiStringResource is a wrapper around an ASCII
    * string buffer that resides outside V8's heap. Implement an
    * ExternalAsciiStringResource to manage the life cycle of the
    * underlying buffer.  Note that the string data must be immutable
    * and that the data must be strict (7-bit) ASCII, not Latin-1 or
    * UTF-8, which would require special treatment internally in the
    * engine and, in the case of UTF-8, do not allow efficient indexing.
    * Use String::New or convert to 16 bit data for non-ASCII.
    */
 
-  class V8_EXPORT ExternalAsciiStringResource
+  class V8EXPORT ExternalAsciiStringResource
       : public ExternalStringResourceBase {
    public:
     /**
      * Override the destructor to manage the life cycle of the underlying
      * buffer.
      */
     virtual ~ExternalAsciiStringResource() {}
     /** The string data from the underlying buffer.*/
     virtual const char* data() const = 0;
     /** The number of ASCII characters in the string.*/
@@ skipping 132 matching lines @@
   V8_INLINE(static Local<String> NewUndetectable(
       const uint16_t* data, int length = -1));
 
   /**
    * Converts an object to a UTF-8-encoded character array.  Useful if
    * you want to print the object.  If conversion to a string fails
    * (e.g. due to an exception in the toString() method of the object)
    * then the length() method returns 0 and the * operator returns
    * NULL.
    */
-  class V8_EXPORT Utf8Value {
+  class V8EXPORT Utf8Value {
    public:
     explicit Utf8Value(Handle<v8::Value> obj);
     ~Utf8Value();
     char* operator*() { return str_; }
     const char* operator*() const { return str_; }
     int length() const { return length_; }
    private:
     char* str_;
     int length_;
 
     // Disallow copying and assigning.
     Utf8Value(const Utf8Value&);
     void operator=(const Utf8Value&);
   };
 
   /**
    * Converts an object to an ASCII string.
    * Useful if you want to print the object.
    * If conversion to a string fails (eg. due to an exception in the toString()
    * method of the object) then the length() method returns 0 and the * operator
    * returns NULL.
    */
-  class V8_EXPORT AsciiValue {
+  class V8EXPORT AsciiValue {
    public:
     // TODO(dcarney): deprecate
     explicit AsciiValue(Handle<v8::Value> obj);
     ~AsciiValue();
     char* operator*() { return str_; }
     const char* operator*() const { return str_; }
     int length() const { return length_; }
    private:
     char* str_;
     int length_;
 
     // Disallow copying and assigning.
     AsciiValue(const AsciiValue&);
     void operator=(const AsciiValue&);
   };
 
   /**
    * Converts an object to a two-byte string.
    * If conversion to a string fails (eg. due to an exception in the toString()
    * method of the object) then the length() method returns 0 and the * operator
    * returns NULL.
    */
-  class V8_EXPORT Value {
+  class V8EXPORT Value {
    public:
     explicit Value(Handle<v8::Value> obj);
     ~Value();
     uint16_t* operator*() { return str_; }
     const uint16_t* operator*() const { return str_; }
     int length() const { return length_; }
    private:
     uint16_t* str_;
     int length_;
 
     // Disallow copying and assigning.
     Value(const Value&);
     void operator=(const Value&);
   };
 
  private:
   void VerifyExternalStringResourceBase(ExternalStringResourceBase* v,
                                         Encoding encoding) const;
   void VerifyExternalStringResource(ExternalStringResource* val) const;
   static void CheckCast(v8::Value* obj);
 };
 
 
 /**
  * A JavaScript symbol (ECMA-262 edition 6)
  *
  * This is an experimental feature. Use at your own risk.
  */
-class V8_EXPORT Symbol : public Primitive {
+class V8EXPORT Symbol : public Primitive {
  public:
   // Returns the print name string of the symbol, or undefined if none.
   Local<Value> Name() const;
 
   // Create a symbol without a print name.
   static Local<Symbol> New(Isolate* isolate);
 
   // Create a symbol with a print name.
   static Local<Symbol> New(Isolate *isolate, const char* data, int length = -1);
 
   V8_INLINE(static Symbol* Cast(v8::Value* obj));
  private:
   Symbol();
   static void CheckCast(v8::Value* obj);
 };
 
 
 /**
  * A JavaScript number value (ECMA-262, 4.3.20)
  */
-class V8_EXPORT Number : public Primitive {
+class V8EXPORT Number : public Primitive {
  public:
   double Value() const;
   static Local<Number> New(double value);
   static Local<Number> New(Isolate* isolate, double value);
   V8_INLINE(static Number* Cast(v8::Value* obj));
  private:
   Number();
   static void CheckCast(v8::Value* obj);
 };
 
 
 /**
  * A JavaScript value representing a signed integer.
  */
-class V8_EXPORT Integer : public Number {
+class V8EXPORT Integer : public Number {
  public:
   static Local<Integer> New(int32_t value);
   static Local<Integer> NewFromUnsigned(uint32_t value);
   static Local<Integer> New(int32_t value, Isolate*);
   static Local<Integer> NewFromUnsigned(uint32_t value, Isolate*);
   int64_t Value() const;
   V8_INLINE(static Integer* Cast(v8::Value* obj));
  private:
   Integer();
   static void CheckCast(v8::Value* obj);
 };
 
 
 /**
  * A JavaScript value representing a 32-bit signed integer.
  */
-class V8_EXPORT Int32 : public Integer {
+class V8EXPORT Int32 : public Integer {
  public:
   int32_t Value() const;
  private:
   Int32();
 };
 
 
 /**
  * A JavaScript value representing a 32-bit unsigned integer.
  */
-class V8_EXPORT Uint32 : public Integer {
+class V8EXPORT Uint32 : public Integer {
  public:
   uint32_t Value() const;
  private:
   Uint32();
 };
 
 
 enum PropertyAttribute {
   None       = 0,
   ReadOnly   = 1 << 0,
@@ skipping 51 matching lines @@
   DEFAULT               = 0,
   ALL_CAN_READ          = 1,
   ALL_CAN_WRITE         = 1 << 1,
   PROHIBITS_OVERWRITING = 1 << 2
 };
 
 
 /**
  * A JavaScript object (ECMA-262, 4.3.3)
  */
-class V8_EXPORT Object : public Value {
+class V8EXPORT Object : public Value {
  public:
   bool Set(Handle<Value> key,
            Handle<Value> value,
            PropertyAttribute attribs = None);
 
   bool Set(uint32_t index, Handle<Value> value);
 
   // Sets a local property on this object bypassing interceptors and
   // overriding accessors or read-only properties.
   //
@@ skipping 251 matching lines @@
   Object();
   static void CheckCast(Value* obj);
   Local<Value> SlowGetInternalField(int index);
   void* SlowGetAlignedPointerFromInternalField(int index);
 };
 
 
 /**
  * An instance of the built-in array constructor (ECMA-262, 15.4.2).
  */
-class V8_EXPORT Array : public Object {
+class V8EXPORT Array : public Object {
  public:
   uint32_t Length() const;
 
   /**
    * Clones an element at index |index|.  Returns an empty
    * handle if cloning fails (for any reason).
    */
   Local<Object> CloneElementAt(uint32_t index);
 
   /**
    * Creates a JavaScript array with the given length. If the length
    * is negative the returned array will have length 0.
    */
   static Local<Array> New(int length = 0);
 
   V8_INLINE(static Array* Cast(Value* obj));
  private:
   Array();
   static void CheckCast(Value* obj);
 };
 
 
 /**
  * A JavaScript function object (ECMA-262, 15.3).
  */
-class V8_EXPORT Function : public Object {
+class V8EXPORT Function : public Object {
  public:
   Local<Object> NewInstance() const;
   Local<Object> NewInstance(int argc, Handle<Value> argv[]) const;
   Local<Value> Call(Handle<Object> recv, int argc, Handle<Value> argv[]);
   void SetName(Handle<String> name);
   Handle<Value> GetName() const;
 
   /**
    * Name inferred from variable or property assignment of this function.
    * Used to facilitate debugging and profiling of JavaScript code written
@@ skipping 35 matching lines @@
 
 #ifndef V8_ARRAY_BUFFER_INTERNAL_FIELD_COUNT
 // The number of required internal fields can be defined by embedder.
 #define V8_ARRAY_BUFFER_INTERNAL_FIELD_COUNT 2
 #endif
 
 /**
  * An instance of the built-in ArrayBuffer constructor (ES6 draft 15.13.5).
  * This API is experimental and may change significantly.
  */
-class V8_EXPORT ArrayBuffer : public Object {
+class V8EXPORT ArrayBuffer : public Object {
  public:
   /**
    * Allocator that V8 uses to allocate |ArrayBuffer|'s memory.
    * The allocator is a global V8 setting. It should be set with
    * V8::SetArrayBufferAllocator prior to creation of a first ArrayBuffer.
    *
    * This API is experimental and may change significantly.
    */
-  class V8_EXPORT Allocator { // NOLINT
+  class V8EXPORT Allocator { // NOLINT
    public:
     virtual ~Allocator() {}
 
     /**
      * Allocate |length| bytes. Return NULL if allocation is not successful.
      * Memory should be initialized to zeroes.
      */
     virtual void* Allocate(size_t length) = 0;
 
     /**
@@ skipping 26 matching lines @@
   /**
    * The contents of an |ArrayBuffer|. Externalization of |ArrayBuffer|
    * returns an instance of this class, populated, with a pointer to data
    * and byte length.
    *
    * The Data pointer of ArrayBuffer::Contents is always allocated with
    * Allocator::Allocate that is set with V8::SetArrayBufferAllocator.
    *
    * This API is experimental and may change significantly.
    */
-  class V8_EXPORT Contents { // NOLINT
+  class V8EXPORT Contents { // NOLINT
    public:
     Contents() : data_(NULL), byte_length_(0) {}
 
     void* Data() const { return data_; }
     size_t ByteLength() const { return byte_length_; }
 
    private:
     void* data_;
     size_t byte_length_;
 
@@ skipping 62 matching lines @@
 #define V8_ARRAY_BUFFER_VIEW_INTERNAL_FIELD_COUNT 2
 #endif
 
 
 /**
  * A base class for an instance of one of "views" over ArrayBuffer,
  * including TypedArrays and DataView (ES6 draft 15.13).
  *
  * This API is experimental and may change significantly.
  */
-class V8_EXPORT ArrayBufferView : public Object {
+class V8EXPORT ArrayBufferView : public Object {
  public:
   /**
    * Returns underlying ArrayBuffer.
    */
   Local<ArrayBuffer> Buffer();
   /**
    * Byte offset in |Buffer|.
    */
   size_t ByteOffset();
   /**
@@ skipping 14 matching lines @@
   ArrayBufferView();
   static void CheckCast(Value* obj);
 };
 
 
 /**
  * A base class for an instance of TypedArray series of constructors
  * (ES6 draft 15.13.6).
  * This API is experimental and may change significantly.
  */
-class V8_EXPORT TypedArray : public ArrayBufferView {
+class V8EXPORT TypedArray : public ArrayBufferView {
  public:
   /**
    * Number of elements in this typed array
    * (e.g. for Int16Array, |ByteLength|/2).
    */
   size_t Length();
 
   V8_INLINE(static TypedArray* Cast(Value* obj));
 
  private:
   TypedArray();
   static void CheckCast(Value* obj);
 };
 
 
 /**
  * An instance of Uint8Array constructor (ES6 draft 15.13.6).
  * This API is experimental and may change significantly.
  */
-class V8_EXPORT Uint8Array : public TypedArray {
+class V8EXPORT Uint8Array : public TypedArray {
  public:
   static Local<Uint8Array> New(Handle<ArrayBuffer> array_buffer,
                                size_t byte_offset, size_t length);
   V8_INLINE(static Uint8Array* Cast(Value* obj));
 
  private:
   Uint8Array();
   static void CheckCast(Value* obj);
 };
 
 
 /**
  * An instance of Uint8ClampedArray constructor (ES6 draft 15.13.6).
  * This API is experimental and may change significantly.
  */
-class V8_EXPORT Uint8ClampedArray : public TypedArray {
+class V8EXPORT Uint8ClampedArray : public TypedArray {
  public:
   static Local<Uint8ClampedArray> New(Handle<ArrayBuffer> array_buffer,
                                size_t byte_offset, size_t length);
   V8_INLINE(static Uint8ClampedArray* Cast(Value* obj));
 
  private:
   Uint8ClampedArray();
   static void CheckCast(Value* obj);
 };
 
 /**
  * An instance of Int8Array constructor (ES6 draft 15.13.6).
  * This API is experimental and may change significantly.
  */
-class V8_EXPORT Int8Array : public TypedArray {
+class V8EXPORT Int8Array : public TypedArray {
  public:
   static Local<Int8Array> New(Handle<ArrayBuffer> array_buffer,
                                size_t byte_offset, size_t length);
   V8_INLINE(static Int8Array* Cast(Value* obj));
 
  private:
   Int8Array();
   static void CheckCast(Value* obj);
 };
 
 
 /**
  * An instance of Uint16Array constructor (ES6 draft 15.13.6).
  * This API is experimental and may change significantly.
  */
-class V8_EXPORT Uint16Array : public TypedArray {
+class V8EXPORT Uint16Array : public TypedArray {
  public:
   static Local<Uint16Array> New(Handle<ArrayBuffer> array_buffer,
                                size_t byte_offset, size_t length);
   V8_INLINE(static Uint16Array* Cast(Value* obj));
 
  private:
   Uint16Array();
   static void CheckCast(Value* obj);
 };
 
 
 /**
  * An instance of Int16Array constructor (ES6 draft 15.13.6).
  * This API is experimental and may change significantly.
  */
-class V8_EXPORT Int16Array : public TypedArray {
+class V8EXPORT Int16Array : public TypedArray {
  public:
   static Local<Int16Array> New(Handle<ArrayBuffer> array_buffer,
                                size_t byte_offset, size_t length);
   V8_INLINE(static Int16Array* Cast(Value* obj));
 
  private:
   Int16Array();
   static void CheckCast(Value* obj);
 };
 
 
 /**
  * An instance of Uint32Array constructor (ES6 draft 15.13.6).
  * This API is experimental and may change significantly.
  */
-class V8_EXPORT Uint32Array : public TypedArray {
+class V8EXPORT Uint32Array : public TypedArray {
  public:
   static Local<Uint32Array> New(Handle<ArrayBuffer> array_buffer,
                                size_t byte_offset, size_t length);
   V8_INLINE(static Uint32Array* Cast(Value* obj));
 
  private:
   Uint32Array();
   static void CheckCast(Value* obj);
 };
 
 
 /**
  * An instance of Int32Array constructor (ES6 draft 15.13.6).
  * This API is experimental and may change significantly.
  */
-class V8_EXPORT Int32Array : public TypedArray {
+class V8EXPORT Int32Array : public TypedArray {
  public:
   static Local<Int32Array> New(Handle<ArrayBuffer> array_buffer,
                                size_t byte_offset, size_t length);
   V8_INLINE(static Int32Array* Cast(Value* obj));
 
  private:
   Int32Array();
   static void CheckCast(Value* obj);
 };
 
 
 /**
  * An instance of Float32Array constructor (ES6 draft 15.13.6).
  * This API is experimental and may change significantly.
  */
-class V8_EXPORT Float32Array : public TypedArray {
+class V8EXPORT Float32Array : public TypedArray {
  public:
   static Local<Float32Array> New(Handle<ArrayBuffer> array_buffer,
                                size_t byte_offset, size_t length);
   V8_INLINE(static Float32Array* Cast(Value* obj));
 
  private:
   Float32Array();
   static void CheckCast(Value* obj);
 };
 
 
 /**
  * An instance of Float64Array constructor (ES6 draft 15.13.6).
  * This API is experimental and may change significantly.
  */
-class V8_EXPORT Float64Array : public TypedArray {
+class V8EXPORT Float64Array : public TypedArray {
  public:
   static Local<Float64Array> New(Handle<ArrayBuffer> array_buffer,
                                size_t byte_offset, size_t length);
   V8_INLINE(static Float64Array* Cast(Value* obj));
 
  private:
   Float64Array();
   static void CheckCast(Value* obj);
 };
 
 
 /**
  * An instance of DataView constructor (ES6 draft 15.13.7).
  * This API is experimental and may change significantly.
  */
-class V8_EXPORT DataView : public ArrayBufferView {
+class V8EXPORT DataView : public ArrayBufferView {
  public:
   static Local<DataView> New(Handle<ArrayBuffer> array_buffer,
                              size_t byte_offset, size_t length);
   V8_INLINE(static DataView* Cast(Value* obj));
 
  private:
   DataView();
   static void CheckCast(Value* obj);
 };
 
 
 /**
  * An instance of the built-in Date constructor (ECMA-262, 15.9).
  */
-class V8_EXPORT Date : public Object {
+class V8EXPORT Date : public Object {
  public:
   static Local<Value> New(double time);
 
   // Deprecated, use Date::ValueOf() instead.
   // TODO(svenpanne) Actually deprecate when Chrome is adapted.
   double NumberValue() const { return ValueOf(); }
 
   /**
    * A specialization of Value::NumberValue that is more efficient
    * because we know the structure of this object.
@@ skipping 17 matching lines @@
   static void DateTimeConfigurationChangeNotification();
 
  private:
   static void CheckCast(v8::Value* obj);
 };
 
 
 /**
  * A Number object (ECMA-262, 4.3.21).
  */
-class V8_EXPORT NumberObject : public Object {
+class V8EXPORT NumberObject : public Object {
  public:
   static Local<Value> New(double value);
 
   // Deprecated, use NumberObject::ValueOf() instead.
   // TODO(svenpanne) Actually deprecate when Chrome is adapted.
   double NumberValue() const { return ValueOf(); }
 
   /**
    * Returns the Number held by the object.
    */
   double ValueOf() const;
 
   V8_INLINE(static NumberObject* Cast(v8::Value* obj));
 
  private:
   static void CheckCast(v8::Value* obj);
 };
 
 
 /**
  * A Boolean object (ECMA-262, 4.3.15).
  */
-class V8_EXPORT BooleanObject : public Object {
+class V8EXPORT BooleanObject : public Object {
  public:
   static Local<Value> New(bool value);
 
   // Deprecated, use BooleanObject::ValueOf() instead.
   // TODO(svenpanne) Actually deprecate when Chrome is adapted.
   bool BooleanValue() const { return ValueOf(); }
 
   /**
    * Returns the Boolean held by the object.
    */
   bool ValueOf() const;
 
   V8_INLINE(static BooleanObject* Cast(v8::Value* obj));
 
  private:
   static void CheckCast(v8::Value* obj);
 };
 
 
 /**
  * A String object (ECMA-262, 4.3.18).
  */
-class V8_EXPORT StringObject : public Object {
+class V8EXPORT StringObject : public Object {
  public:
   static Local<Value> New(Handle<String> value);
 
   // Deprecated, use StringObject::ValueOf() instead.
   // TODO(svenpanne) Actually deprecate when Chrome is adapted.
   Local<String> StringValue() const { return ValueOf(); }
 
   /**
    * Returns the String held by the object.
    */
   Local<String> ValueOf() const;
 
   V8_INLINE(static StringObject* Cast(v8::Value* obj));
 
  private:
   static void CheckCast(v8::Value* obj);
 };
 
 
 /**
  * A Symbol object (ECMA-262 edition 6).
  *
  * This is an experimental feature. Use at your own risk.
  */
-class V8_EXPORT SymbolObject : public Object {
+class V8EXPORT SymbolObject : public Object {
  public:
   static Local<Value> New(Isolate* isolate, Handle<Symbol> value);
 
   // Deprecated, use SymbolObject::ValueOf() instead.
   // TODO(svenpanne) Actually deprecate when Chrome is adapted.
   Local<Symbol> SymbolValue() const { return ValueOf(); }
 
   /**
    * Returns the Symbol held by the object.
    */
   Local<Symbol> ValueOf() const;
 
   V8_INLINE(static SymbolObject* Cast(v8::Value* obj));
 
  private:
   static void CheckCast(v8::Value* obj);
 };
 
 
 /**
  * An instance of the built-in RegExp constructor (ECMA-262, 15.10).
  */
-class V8_EXPORT RegExp : public Object {
+class V8EXPORT RegExp : public Object {
  public:
   /**
    * Regular expression flag bits. They can be or'ed to enable a set
    * of flags.
    */
   enum Flags {
     kNone = 0,
     kGlobal = 1,
     kIgnoreCase = 2,
     kMultiline = 4
@@ skipping 26 matching lines @@
 
  private:
   static void CheckCast(v8::Value* obj);
 };
 
 
 /**
  * A JavaScript value that wraps a C++ void*. This type of value is mainly used
  * to associate C++ data structures with JavaScript objects.
  */
-class V8_EXPORT External : public Value {
+class V8EXPORT External : public Value {
  public:
   static Local<External> New(void* value);
   V8_INLINE(static External* Cast(Value* obj));
   void* Value() const;
  private:
   static void CheckCast(v8::Value* obj);
 };
 
 
 // --- Templates ---
 
 
 /**
  * The superclass of object and function templates.
  */
-class V8_EXPORT Template : public Data {
+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);
   V8_INLINE(void Set(const char* name, Handle<Data> value));
  private:
   Template();
 
   friend class ObjectTemplate;
   friend class FunctionTemplate;
@@ skipping 67 matching lines @@
                    internal::Object** values,
                    int length,
                    bool is_construct_call));
   internal::Object** implicit_args_;
   internal::Object** values_;
   int length_;
   bool is_construct_call_;
 };
 
 
-class V8_EXPORT Arguments : public FunctionCallbackInfo<Value> {
+class V8EXPORT Arguments : public FunctionCallbackInfo<Value> {
  private:
   friend class internal::FunctionCallbackArguments;
   V8_INLINE(Arguments(internal::Object** implicit_args,
                       internal::Object** values,
                       int length,
                       bool is_construct_call));
 };
 
 /**
  * The information passed to a property callback about the context
@@ skipping 20 matching lines @@
   static const int kReturnValueIndex = -3;
   static const int kReturnValueDefaultValueIndex = -4;
   static const int kIsolateIndex = -5;
 
   V8_INLINE(PropertyCallbackInfo(internal::Object** args))
       : args_(args) { }
   internal::Object** args_;
 };
 
 
-class V8_EXPORT AccessorInfo : public PropertyCallbackInfo<Value> {
+class V8EXPORT AccessorInfo : public PropertyCallbackInfo<Value> {
  private:
   friend class internal::PropertyCallbackArguments;
   V8_INLINE(AccessorInfo(internal::Object** args))
       : PropertyCallbackInfo<Value>(args) { }
 };
 
 
 typedef Handle<Value> (*InvocationCallback)(const Arguments& args);
 typedef void (*FunctionCallback)(const FunctionCallbackInfo<Value>& info);
 
@@ skipping 227 matching lines @@
  *
  * The Child function and Child instance will have the following
  * properties:
  *
  * \code
  *   child_func.prototype.__proto__ == function.prototype;
  *   child_instance.instance_accessor calls 'InstanceAccessorCallback'
  *   child_instance.instance_property == 3;
  * \endcode
  */
-class V8_EXPORT FunctionTemplate : public Template {
+class V8EXPORT FunctionTemplate : public Template {
  public:
   /** Creates a function template.*/
   V8_DEPRECATED(static Local<FunctionTemplate> New(
       InvocationCallback callback,
       Handle<Value> data = Handle<Value>(),
       Handle<Signature> signature = Handle<Signature>(),
       int length = 0));
   static Local<FunctionTemplate> New(
       FunctionCallback callback = 0,
       Handle<Value> data = Handle<Value>(),
@@ skipping 70 matching lines @@
   friend class ObjectTemplate;
 };
 
 
 /**
  * An ObjectTemplate is used to create objects at runtime.
  *
  * Properties added to an ObjectTemplate are added to each object
  * created from the ObjectTemplate.
  */
-class V8_EXPORT ObjectTemplate : public Template {
+class V8EXPORT ObjectTemplate : public Template {
  public:
   /** Creates an ObjectTemplate. */
   static Local<ObjectTemplate> New();
 
   /** Creates a new instance of this template.*/
   Local<Object> NewInstance();
 
   /**
    * Sets an accessor on the object template.
    *
@@ skipping 165 matching lines @@
   ObjectTemplate();
   static Local<ObjectTemplate> New(Handle<FunctionTemplate> constructor);
   friend class FunctionTemplate;
 };
 
 
 /**
  * A Signature specifies which receivers and arguments are valid
  * parameters to a function.
  */
-class V8_EXPORT Signature : public Data {
+class V8EXPORT Signature : public Data {
  public:
   static Local<Signature> New(Handle<FunctionTemplate> receiver =
                                   Handle<FunctionTemplate>(),
                               int argc = 0,
                               Handle<FunctionTemplate> argv[] = 0);
  private:
   Signature();
 };
 
 
 /**
  * An AccessorSignature specifies which receivers are valid parameters
  * to an accessor callback.
  */
-class V8_EXPORT AccessorSignature : public Data {
+class V8EXPORT AccessorSignature : public Data {
  public:
   static Local<AccessorSignature> New(Handle<FunctionTemplate> receiver =
                                           Handle<FunctionTemplate>());
  private:
   AccessorSignature();
 };
 
 
-class V8_EXPORT DeclaredAccessorDescriptor : public Data {
+class V8EXPORT DeclaredAccessorDescriptor : public Data {
  private:
   DeclaredAccessorDescriptor();
 };
 
 
-class V8_EXPORT ObjectOperationDescriptor : public Data {
+class V8EXPORT ObjectOperationDescriptor : public Data {
  public:
   // This function is not yet stable and should not be used at this time.
   static Local<RawOperationDescriptor> NewInternalFieldDereference(
       Isolate* isolate,
       int internal_field);
  private:
   ObjectOperationDescriptor();
 };
 
 
 enum DeclaredAccessorDescriptorDataType {
     kDescriptorBoolType,
     kDescriptorInt8Type, kDescriptorUint8Type,
     kDescriptorInt16Type, kDescriptorUint16Type,
     kDescriptorInt32Type, kDescriptorUint32Type,
     kDescriptorFloatType, kDescriptorDoubleType
 };
 
 
-class V8_EXPORT RawOperationDescriptor : public Data {
+class V8EXPORT RawOperationDescriptor : public Data {
  public:
   Local<DeclaredAccessorDescriptor> NewHandleDereference(Isolate* isolate);
   Local<RawOperationDescriptor> NewRawDereference(Isolate* isolate);
   Local<RawOperationDescriptor> NewRawShift(Isolate* isolate,
                                             int16_t byte_offset);
   Local<DeclaredAccessorDescriptor> NewPointerCompare(Isolate* isolate,
                                                       void* compare_value);
   Local<DeclaredAccessorDescriptor> NewPrimitiveValue(
       Isolate* isolate,
       DeclaredAccessorDescriptorDataType data_type,
@@ skipping 12 matching lines @@
 
  private:
   RawOperationDescriptor();
 };
 
 
 /**
  * A utility for determining the type of objects based on the template
  * they were constructed from.
  */
-class V8_EXPORT TypeSwitch : public Data {
+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();
 };
 
 
 // --- Extensions ---
 
-class V8_EXPORT ExternalAsciiStringResourceImpl
+class V8EXPORT ExternalAsciiStringResourceImpl
     : public String::ExternalAsciiStringResource {
  public:
   ExternalAsciiStringResourceImpl() : data_(0), length_(0) {}
   ExternalAsciiStringResourceImpl(const char* data, size_t length)
       : data_(data), length_(length) {}
   const char* data() const { return data_; }
   size_t length() const { return length_; }
 
  private:
   const char* data_;
   size_t length_;
 };
 
 /**
  * Ignore
  */
-class V8_EXPORT Extension {  // NOLINT
+class V8EXPORT Extension {  // NOLINT
  public:
   // Note that the strings passed into this constructor must live as long
   // as the Extension itself.
   Extension(const char* name,
             const char* source = 0,
             int dep_count = 0,
             const char** deps = 0,
             int source_length = -1);
   virtual ~Extension() { }
   virtual v8::Handle<v8::FunctionTemplate>
@@ skipping 17 matching lines @@
   int dep_count_;
   const char** deps_;
   bool auto_enable_;
 
   // Disallow copying and assigning.
   Extension(const Extension&);
   void operator=(const Extension&);
 };
 
 
-void V8_EXPORT RegisterExtension(Extension* extension);
+void V8EXPORT RegisterExtension(Extension* extension);
 
 
 /**
  * Ignore
  */
-class V8_EXPORT DeclareExtension {
+class V8EXPORT DeclareExtension {
  public:
   V8_INLINE(DeclareExtension(Extension* extension)) {
     RegisterExtension(extension);
   }
 };
 
 
 // --- Statics ---
 
 
-Handle<Primitive> V8_EXPORT Undefined();
-Handle<Primitive> V8_EXPORT Null();
-Handle<Boolean> V8_EXPORT True();
-Handle<Boolean> V8_EXPORT False();
+Handle<Primitive> V8EXPORT Undefined();
+Handle<Primitive> V8EXPORT Null();
+Handle<Boolean> V8EXPORT True();
+Handle<Boolean> V8EXPORT False();
 
 V8_INLINE(Handle<Primitive> Undefined(Isolate* isolate));
 V8_INLINE(Handle<Primitive> Null(Isolate* isolate));
 V8_INLINE(Handle<Boolean> True(Isolate* isolate));
 V8_INLINE(Handle<Boolean> False(Isolate* isolate));
 
 
 /**
  * A set of constraints that specifies the limits of the runtime's memory use.
  * You must set the heap size before initializing the VM - the size cannot be
  * adjusted after the VM is initialized.
  *
  * If you are using threads then you should hold the V8::Locker lock while
  * setting the stack limit and you must set a non-default stack limit separately
  * for each thread.
  */
-class V8_EXPORT ResourceConstraints {
+class V8EXPORT ResourceConstraints {
  public:
   ResourceConstraints();
   int max_young_space_size() const { return max_young_space_size_; }
   void set_max_young_space_size(int value) { max_young_space_size_ = value; }
   int max_old_space_size() const { return max_old_space_size_; }
   void set_max_old_space_size(int value) { max_old_space_size_ = value; }
   int max_executable_size() { return max_executable_size_; }
   void set_max_executable_size(int value) { max_executable_size_ = value; }
   uint32_t* stack_limit() const { return stack_limit_; }
   // Sets an address beyond which the VM's stack may not grow.
   void set_stack_limit(uint32_t* value) { stack_limit_ = value; }
  private:
   int max_young_space_size_;
   int max_old_space_size_;
   int max_executable_size_;
   uint32_t* stack_limit_;
 };
 
 
-bool V8_EXPORT SetResourceConstraints(ResourceConstraints* constraints);
+bool V8EXPORT SetResourceConstraints(ResourceConstraints* constraints);
 
 
 // --- Exceptions ---
 
 
 typedef void (*FatalErrorCallback)(const char* location, const char* message);
 
 
 typedef void (*MessageCallback)(Handle<Message> message, Handle<Value> error);
 
 
 /**
  * Schedules an exception to be thrown when returning to JavaScript.  When an
  * exception has been scheduled it is illegal to invoke any JavaScript
  * operation; the caller must return immediately and only after the exception
  * has been handled does it become legal to invoke JavaScript operations.
  */
-Handle<Value> V8_EXPORT ThrowException(Handle<Value> exception);
+Handle<Value> V8EXPORT ThrowException(Handle<Value> exception);
 
 /**
  * Create new error objects by calling the corresponding error object
  * constructor with the message.
  */
-class V8_EXPORT Exception {
+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);
 };
 
 
 // --- Counters Callbacks ---
@@ skipping 73 matching lines @@
 
 typedef void (*GCCallback)();
 
 
 /**
  * Collection of V8 heap information.
  *
  * Instances of this class can be passed to v8::V8::HeapStatistics to
  * get heap statistics from V8.
  */
-class V8_EXPORT HeapStatistics {
+class V8EXPORT HeapStatistics {
  public:
   HeapStatistics();
   size_t total_heap_size() { return total_heap_size_; }
   size_t total_heap_size_executable() { return total_heap_size_executable_; }
   size_t total_physical_size() { return total_physical_size_; }
   size_t used_heap_size() { return used_heap_size_; }
   size_t heap_size_limit() { return heap_size_limit_; }
 
  private:
   size_t total_heap_size_;
@@ skipping 11 matching lines @@
 
 /**
  * Isolate represents an isolated instance of the V8 engine.  V8
  * isolates have completely separate states.  Objects from one isolate
  * must not be used in other isolates.  When V8 is initialized a
  * default isolate is implicitly created and entered.  The embedder
  * can create additional isolates and use them in parallel in multiple
  * threads.  An isolate can be entered by at most one thread at any
  * given time.  The Locker/Unlocker API must be used to synchronize.
  */
-class V8_EXPORT Isolate {
+class V8EXPORT Isolate {
  public:
   /**
    * Stack-allocated class which sets the isolate for all operations
    * executed within a local scope.
    */
-  class V8_EXPORT Scope {
+  class V8EXPORT Scope {
    public:
     explicit Scope(Isolate* isolate) : isolate_(isolate) {
       isolate->Enter();
     }
 
     ~Scope() { isolate_->Exit(); }
 
    private:
     Isolate* const isolate_;
 
@@ skipping 127 matching lines @@
  private:
   Isolate();
   Isolate(const Isolate&);
   ~Isolate();
   Isolate& operator=(const Isolate&);
   void* operator new(size_t size);
   void operator delete(void*, size_t);
 };
 
 
-class V8_EXPORT StartupData {
+class V8EXPORT StartupData {
  public:
   enum CompressionAlgorithm {
     kUncompressed,
     kBZip2
   };
 
   const char* data;
   int compressed_size;
   int raw_size;
 };
 
 
 /**
  * A helper class for driving V8 startup data decompression.  It is based on
  * "CompressedStartupData" API functions from the V8 class.  It isn't mandatory
  * for an embedder to use this class, instead, API functions can be used
  * directly.
  *
  * For an example of the class usage, see the "shell.cc" sample application.
  */
-class V8_EXPORT StartupDataDecompressor {  // NOLINT
+class V8EXPORT StartupDataDecompressor {  // NOLINT
  public:
   StartupDataDecompressor();
   virtual ~StartupDataDecompressor();
   int Decompress();
 
  protected:
   virtual int DecompressData(char* raw_data,
                              int* raw_data_size,
                              const char* compressed_data,
                              int compressed_data_size) = 0;
@@ skipping 123 matching lines @@
  * Callback function passed to SetJitCodeEventHandler.
  *
  * \param event code add, move or removal event.
  */
 typedef void (*JitCodeEventHandler)(const JitCodeEvent* event);
 
 
 /**
  * Interface for iterating through all external resources in the heap.
  */
-class V8_EXPORT ExternalResourceVisitor {  // NOLINT
+class V8EXPORT ExternalResourceVisitor {  // NOLINT
  public:
   virtual ~ExternalResourceVisitor() {}
   virtual void VisitExternalString(Handle<String> string) {}
 };
 
 
 /**
  * Interface for iterating through all the persistent handles in the heap.
  */
-class V8_EXPORT PersistentHandleVisitor {  // NOLINT
+class V8EXPORT PersistentHandleVisitor {  // NOLINT
  public:
   virtual ~PersistentHandleVisitor() {}
   virtual void VisitPersistentHandle(Persistent<Value>* value,
                                      uint16_t class_id) {}
 };
 
 
 /**
  * Asserts that no action is performed that could cause a handle's value
  * to be modified. Useful when otherwise unsafe handle operations need to
  * be performed.
  */
-class V8_EXPORT AssertNoGCScope {
+class V8EXPORT AssertNoGCScope {
 #ifndef DEBUG
   // TODO(yangguo): remove isolate argument.
   V8_INLINE(AssertNoGCScope(Isolate* isolate)) { }
 #else
   AssertNoGCScope(Isolate* isolate);
   ~AssertNoGCScope();
  private:
   void* disallow_heap_allocation_;
 #endif
 };
 
 
 /**
  * Container class for static utility functions.
  */
-class V8_EXPORT V8 {
+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);
@@ skipping 436 matching lines @@
   V8();
 
   static internal::Object** GlobalizeReference(internal::Isolate* isolate,
                                                internal::Object** handle);
   static void DisposeGlobal(internal::Object** global_handle);
   typedef WeakReferenceCallbacks<Value, void>::Revivable RevivableCallback;
   static void MakeWeak(internal::Object** global_handle,
                        void* data,
                        RevivableCallback weak_reference_callback);
   static void ClearWeak(internal::Object** global_handle);
-  static int Eternalize(internal::Isolate* isolate,
-                        internal::Object** handle);
-  static internal::Object** GetEternal(internal::Isolate* isolate, int index);
 
   template <class T> friend class Handle;
   template <class T> friend class Local;
   template <class T> friend class Persistent;
   friend class Context;
 };
 
 
 /**
  * An external exception handler.
  */
-class V8_EXPORT TryCatch {
+class V8EXPORT TryCatch {
  public:
   /**
    * Creates a new try/catch block and registers it with v8.  Note that
    * all TryCatch blocks should be stack allocated because the memory
    * location itself is compared against JavaScript try/catch blocks.
    */
   TryCatch();
 
   /**
    * Unregisters and deletes this try/catch block.
@@ skipping 112 matching lines @@
   friend class v8::internal::Isolate;
 };
 
 
 // --- Context ---
 
 
 /**
  * Ignore
  */
-class V8_EXPORT ExtensionConfiguration {
+class V8EXPORT ExtensionConfiguration {
  public:
   ExtensionConfiguration(int name_count, const char* names[])
       : name_count_(name_count), names_(names) { }
  private:
   friend class ImplementationUtilities;
   int name_count_;
   const char** names_;
 };
 
 
 /**
  * A sandboxed execution context with its own set of built-in objects
  * and functions.
  */
-class V8_EXPORT Context {
+class V8EXPORT Context {
  public:
   /**
    * Returns the global proxy object or global object itself for
    * detached contexts.
    *
    * Global proxy object is a thin wrapper whose prototype points to
    * actual context's global object with the properties like Object, etc.
    * This is done that way for security reasons (for more details see
    * https://wiki.mozilla.org/Gecko:SplitWindow).
    *
@@ skipping 264 matching lines @@
  *       // V8 not locked.
  *     }
  *     isolate->Enter();
  *     // V8 locked again (2 levels).
  *   }
  *   // V8 still locked (1 level).
  * }
  * // V8 Now no longer locked.
  * \endcode
  */
-class V8_EXPORT Unlocker {
+class V8EXPORT Unlocker {
  public:
   /**
    * Initialize Unlocker for a given Isolate.
    */
   V8_INLINE(explicit Unlocker(Isolate* isolate)) { Initialize(isolate); }
 
   /** Deprecated. Use Isolate version instead. */
   V8_DEPRECATED(Unlocker());
 
   ~Unlocker();
  private:
   void Initialize(Isolate* isolate);
 
   internal::Isolate* isolate_;
 };
 
 
-class V8_EXPORT Locker {
+class V8EXPORT Locker {
  public:
   /**
    * Initialize Locker for a given Isolate.
    */
   V8_INLINE(explicit Locker(Isolate* isolate)) { Initialize(isolate); }
 
   /** Deprecated. Use Isolate version instead. */
   V8_DEPRECATED(Locker());
 
   ~Locker();
@@ skipping 40 matching lines @@
 
 /**
  * A struct for exporting HeapStats data from V8, using "push" model.
  */
 struct HeapStatsUpdate;
 
 
 /**
  * An interface for exporting data from V8, using "push" model.
  */
-class V8_EXPORT OutputStream {  // NOLINT
+class V8EXPORT OutputStream {  // NOLINT
  public:
   enum OutputEncoding {
     kAscii = 0  // 7-bit ASCII.
   };
   enum WriteResult {
     kContinue = 0,
     kAbort = 1
   };
   virtual ~OutputStream() {}
   /** Notify about the end of stream. */
@@ skipping 16 matching lines @@
   virtual WriteResult WriteHeapStatsChunk(HeapStatsUpdate* data, int count) {
     return kAbort;
   };
 };
 
 
 /**
  * An interface for reporting progress and controlling long-running
  * activities.
  */
-class V8_EXPORT ActivityControl {  // NOLINT
+class V8EXPORT ActivityControl {  // NOLINT
  public:
   enum ControlOption {
     kContinue = 0,
     kAbort = 1
   };
   virtual ~ActivityControl() {}
   /**
    * Notify about current progress. The activity can be stopped by
    * returning kAbort as the callback result.
    */
@@ skipping 102 matching lines @@
   static const int kStringEncodingMask = 0x4;
   static const int kExternalTwoByteRepresentationTag = 0x02;
   static const int kExternalAsciiRepresentationTag = 0x06;
 
   static const int kIsolateEmbedderDataOffset = 1 * kApiPointerSize;
   static const int kIsolateRootsOffset = 3 * kApiPointerSize;
   static const int kUndefinedValueRootIndex = 5;
   static const int kNullValueRootIndex = 7;
   static const int kTrueValueRootIndex = 8;
   static const int kFalseValueRootIndex = 9;
-  static const int kEmptyStringRootIndex = 133;
+  static const int kEmptyStringRootIndex = 135;
 
   static const int kNodeClassIdOffset = 1 * kApiPointerSize;
   static const int kNodeFlagsOffset = 1 * kApiPointerSize + 3;
   static const int kNodeStateMask = 0xf;
   static const int kNodeStateIsWeakValue = 2;
-  static const int kNodeStateIsPendingValue = 3;
   static const int kNodeStateIsNearDeathValue = 4;
   static const int kNodeIsIndependentShift = 4;
   static const int kNodeIsPartiallyDependentShift = 5;
 
   static const int kJSObjectType = 0xb1;
   static const int kFirstNonstringType = 0x80;
   static const int kOddballType = 0x83;
   static const int kForeignType = 0x87;
 
   static const int kUndefinedOddballKind = 5;
@@ skipping 153 matching lines @@
 template <class T>
 Local<T> Local<T>::New(Isolate* isolate, T* that) {
   if (that == NULL) return Local<T>();
   T* that_ptr = that;
   internal::Object** p = reinterpret_cast<internal::Object**>(that_ptr);
   return Local<T>(reinterpret_cast<T*>(HandleScope::CreateHandle(
       reinterpret_cast<internal::Isolate*>(isolate), *p)));
 }
 
 
-template<class T>
-int Local<T>::Eternalize(Isolate* isolate) {
-  return V8::Eternalize(reinterpret_cast<internal::Isolate*>(isolate),
-                        reinterpret_cast<internal::Object**>(this->val_));
-}
-
-
-template<class T>
-Local<T> Local<T>::GetEternal(Isolate* isolate, int index) {
-  internal::Object** handle =
-      V8::GetEternal(reinterpret_cast<internal::Isolate*>(isolate), index);
-  return Local<T>(T::Cast(reinterpret_cast<Value*>(handle)));
-}
-
-
 #ifdef V8_USE_UNSAFE_HANDLES
 template <class T>
 Persistent<T> Persistent<T>::New(Handle<T> that) {
   return New(Isolate::GetCurrent(), that.val_);
 }
 
 
 template <class T>
 Persistent<T> Persistent<T>::New(Isolate* isolate, Handle<T> that) {
   return New(Isolate::GetCurrent(), that.val_);
@@ skipping 22 matching lines @@
   if (this->IsEmpty()) return false;
   return I::GetNodeFlag(reinterpret_cast<internal::Object**>(this->val_),
                         I::kNodeIsIndependentShift);
 }
 
 
 template <class T>
 bool Persistent<T>::IsNearDeath() const {
   typedef internal::Internals I;
   if (this->IsEmpty()) return false;
-  uint8_t node_state =
-      I::GetNodeState(reinterpret_cast<internal::Object**>(this->val_));
-  return node_state == I::kNodeStateIsNearDeathValue ||
-      node_state == I::kNodeStateIsPendingValue;
+  return I::GetNodeState(reinterpret_cast<internal::Object**>(this->val_)) ==
+      I::kNodeStateIsNearDeathValue;
 }
 
 
 template <class T>
 bool Persistent<T>::IsWeak() const {
   typedef internal::Internals I;
   if (this->IsEmpty()) return false;
   return I::GetNodeState(reinterpret_cast<internal::Object**>(this->val_)) ==
       I::kNodeStateIsWeakValue;
 }
@@ skipping 845 matching lines @@
 
 
 /**
  * \example process.cc
  */
 
 
 }  // namespace v8
 
 
+#undef V8EXPORT
 #undef TYPE_CHECK
 
 
 #endif  // V8_H_