v8-debug.h   v8-debug.h 
skipping to change at line 127 skipping to change at line 127
virtual Handle<Object> GetEventData() const = 0; virtual Handle<Object> GetEventData() const = 0;
/** /**
* Get the debugger protocol JSON. * Get the debugger protocol JSON.
*/ */
virtual Handle<String> GetJSON() const = 0; virtual Handle<String> GetJSON() const = 0;
/** /**
* Get the context active when the debug event happened. Note this is n ot * Get the context active when the debug event happened. Note this is n ot
* the current active context as the JavaScript part of the debugger is * the current active context as the JavaScript part of the debugger is
* running in it's own context which is entered at this point. * running in its own context which is entered at this point.
*/ */
virtual Handle<Context> GetEventContext() const = 0; virtual Handle<Context> GetEventContext() const = 0;
/** /**
* Client data passed with the corresponding request if any. This is th e * Client data passed with the corresponding request if any. This is th e
* client_data data value passed into Debug::SendCommand along with the * client_data data value passed into Debug::SendCommand along with the
* request that led to the message or NULL if the message is an event. The * request that led to the message or NULL if the message is an event. The
* debugger takes ownership of the data and will delete it even if ther e is * debugger takes ownership of the data and will delete it even if ther e is
* no message handler. * no message handler.
*/ */
skipping to change at line 163 skipping to change at line 163
/** /**
* Access to execution state and event data of the debug event. Don't s tore * Access to execution state and event data of the debug event. Don't s tore
* these cross callbacks as their content becomes invalid. * these cross callbacks as their content becomes invalid.
*/ */
virtual Handle<Object> GetExecutionState() const = 0; virtual Handle<Object> GetExecutionState() const = 0;
virtual Handle<Object> GetEventData() const = 0; virtual Handle<Object> GetEventData() const = 0;
/** /**
* Get the context active when the debug event happened. Note this is n ot * Get the context active when the debug event happened. Note this is n ot
* the current active context as the JavaScript part of the debugger is * the current active context as the JavaScript part of the debugger is
* running in it's own context which is entered at this point. * running in its own context which is entered at this point.
*/ */
virtual Handle<Context> GetEventContext() const = 0; virtual Handle<Context> GetEventContext() const = 0;
/** /**
* Client data passed with the corresponding callbak whet it was regist * Client data passed with the corresponding callback when it was
ered. * registered.
*/ */
virtual Handle<Value> GetCallbackData() const = 0; virtual Handle<Value> GetCallbackData() const = 0;
/** /**
* Client data passed to DebugBreakForCommand function. The * Client data passed to DebugBreakForCommand function. The
* debugger takes ownership of the data and will delete it even if * debugger takes ownership of the data and will delete it even if
* there is no message handler. * there is no message handler.
*/ */
virtual ClientData* GetClientData() const = 0; virtual ClientData* GetClientData() const = 0;
skipping to change at line 308 skipping to change at line 309
/** /**
* Run a JavaScript function in the debugger. * Run a JavaScript function in the debugger.
* \param fun the function to call * \param fun the function to call
* \param data passed as second argument to the function * \param data passed as second argument to the function
* With this call the debugger is entered and the function specified is ca lled * With this call the debugger is entered and the function specified is ca lled
* with the execution state as the first argument. This makes it possible to * with the execution state as the first argument. This makes it possible to
* get access to information otherwise not available during normal JavaScr ipt * get access to information otherwise not available during normal JavaScr ipt
* execution e.g. details on stack frames. Receiver of the function call w ill * execution e.g. details on stack frames. Receiver of the function call w ill
* be the debugger context global object, however this is a subject to cha nge. * be the debugger context global object, however this is a subject to cha nge.
* The following example show a JavaScript function which when passed to * The following example shows a JavaScript function which when passed to
* v8::Debug::Call will return the current line of JavaScript execution. * v8::Debug::Call will return the current line of JavaScript execution.
* *
* \code * \code
* function frame_source_line(exec_state) { * function frame_source_line(exec_state) {
* return exec_state.frame(0).sourceLine(); * return exec_state.frame(0).sourceLine();
* } * }
* \endcode * \endcode
*/ */
static Local<Value> Call(v8::Handle<v8::Function> fun, static Local<Value> Call(v8::Handle<v8::Function> fun,
Handle<Value> data = Handle<Value>()); Handle<Value> data = Handle<Value>());
skipping to change at line 350 skipping to change at line 351
* remote debugger) but they all must be handled synchronously: V8 cannot * remote debugger) but they all must be handled synchronously: V8 cannot
* do 2 things at one time so normal script execution must be interrupted * do 2 things at one time so normal script execution must be interrupted
* for a while. * for a while.
* *
* Generally when message arrives V8 may be in one of 3 states: * Generally when message arrives V8 may be in one of 3 states:
* 1. V8 is running script; V8 will automatically interrupt and process a ll * 1. V8 is running script; V8 will automatically interrupt and process a ll
* pending messages (however auto_break flag should be enabled); * pending messages (however auto_break flag should be enabled);
* 2. V8 is suspended on debug breakpoint; in this state V8 is dedicated * 2. V8 is suspended on debug breakpoint; in this state V8 is dedicated
* to reading and processing debug messages; * to reading and processing debug messages;
* 3. V8 is not running at all or has called some long-working C++ functi on; * 3. V8 is not running at all or has called some long-working C++ functi on;
* by default it means that processing of all debug message will be defer red * by default it means that processing of all debug messages will be defe rred
* until V8 gets control again; however, embedding application may improv e * until V8 gets control again; however, embedding application may improv e
* this by manually calling this method. * this by manually calling this method.
* *
* It makes sense to call this method whenever a new debug message arrive d and * It makes sense to call this method whenever a new debug message arrive d and
* V8 is not already running. Method v8::Debug::SetDebugMessageDispatchHa ndler * V8 is not already running. Method v8::Debug::SetDebugMessageDispatchHa ndler
* should help with the former condition. * should help with the former condition.
* *
* Technically this method in many senses is equivalent to executing empt y * Technically this method in many senses is equivalent to executing empt y
* script: * script:
* 1. It does nothing except for processing all pending debug messages. * 1. It does nothing except for processing all pending debug messages.
skipping to change at line 374 skipping to change at line 375
* including all native calls; * including all native calls;
* b. no other thread should call V8 while this method is running * b. no other thread should call V8 while this method is running
* (v8::Locker may be used here). * (v8::Locker may be used here).
* *
* "Evaluate" debug command behavior currently is not specified in scope * "Evaluate" debug command behavior currently is not specified in scope
* of this method. * of this method.
*/ */
static void ProcessDebugMessages(); static void ProcessDebugMessages();
/** /**
* Debugger is running in it's own context which is entered while debugge r * Debugger is running in its own context which is entered while debugger
* messages are being dispatched. This is an explicit getter for this * messages are being dispatched. This is an explicit getter for this
* debugger context. Note that the content of the debugger context is sub ject * debugger context. Note that the content of the debugger context is sub ject
* to change. * to change.
*/ */
static Local<Context> GetDebugContext(); static Local<Context> GetDebugContext();
}; };
} // namespace v8 } // namespace v8
#undef EXPORT #undef EXPORT
 End of changes. 6 change blocks. 
7 lines changed or deleted 7 lines changed or added


 v8-profiler.h   v8-profiler.h 
skipping to change at line 203 skipping to change at line 203
* activity. All previously returned pointers to profiles and their * activity. All previously returned pointers to profiles and their
* contents become invalid after this call. * contents become invalid after this call.
*/ */
static void DeleteAllProfiles(); static void DeleteAllProfiles();
}; };
class HeapGraphNode; class HeapGraphNode;
/** /**
* HeapSnapshotEdge represents a directed connection between heap * HeapSnapshotEdge represents a directed connection between heap
* graph nodes: from retaners to retained nodes. * graph nodes: from retainers to retained nodes.
*/ */
class V8EXPORT HeapGraphEdge { class V8EXPORT HeapGraphEdge {
public: public:
enum Type { enum Type {
kContextVariable = 0, // A variable from a function context. kContextVariable = 0, // A variable from a function context.
kElement = 1, // An element of an array. kElement = 1, // An element of an array.
kProperty = 2, // A named object property. kProperty = 2, // A named object property.
kInternal = 3, // A link that can't be accessed from JS, kInternal = 3, // A link that can't be accessed from JS,
// thus, its name isn't a real property name // thus, its name isn't a real property name
// (e.g. parts of a ConsString). // (e.g. parts of a ConsString).
skipping to change at line 352 skipping to change at line 352
* Deletes the snapshot and removes it from HeapProfiler's list. * Deletes the snapshot and removes it from HeapProfiler's list.
* All pointers to nodes, edges and paths previously returned become * All pointers to nodes, edges and paths previously returned become
* invalid. * invalid.
*/ */
void Delete(); void Delete();
/** /**
* Prepare a serialized representation of the snapshot. The result * Prepare a serialized representation of the snapshot. The result
* is written into the stream provided in chunks of specified size. * is written into the stream provided in chunks of specified size.
* The total length of the serialized snapshot is unknown in * The total length of the serialized snapshot is unknown in
* advance, it is can be roughly equal to JS heap size (that means, * advance, it can be roughly equal to JS heap size (that means,
* it can be really big - tens of megabytes). * it can be really big - tens of megabytes).
* *
* For the JSON format, heap contents are represented as an object * For the JSON format, heap contents are represented as an object
* with the following structure: * with the following structure:
* *
* { * {
* snapshot: {title: "...", uid: nnn}, * snapshot: {title: "...", uid: nnn},
* nodes: [ * nodes: [
* meta-info (JSON string), * meta-info (JSON string),
* nodes themselves * nodes themselves
 End of changes. 2 change blocks. 
2 lines changed or deleted 2 lines changed or added


 v8.h   v8.h 
skipping to change at line 159 skipping to change at line 159
* *
* There are two types of handles: local and persistent handles. * There are two types of handles: local and persistent handles.
* Local handles are light-weight and transient and typically used in * Local handles are light-weight and transient and typically used in
* local operations. They are managed by HandleScopes. Persistent * local operations. They are managed by HandleScopes. Persistent
* handles can be used when storing objects across several independent * handles can be used when storing objects across several independent
* operations and have to be explicitly deallocated when they're no * operations and have to be explicitly deallocated when they're no
* longer used. * longer used.
* *
* It is safe to extract the object stored in the handle by * It is safe to extract the object stored in the handle by
* dereferencing the handle (for instance, to extract the Object* from * dereferencing the handle (for instance, to extract the Object* from
* an Handle<Object>); the value will still be governed by a handle * a Handle<Object>); the value will still be governed by a handle
* behind the scenes and the same rules apply to these values as to * behind the scenes and the same rules apply to these values as to
* their handles. * their handles.
*/ */
template <class T> class Handle { template <class T> class Handle {
public: public:
/** /**
* Creates an empty handle. * Creates an empty handle.
*/ */
inline Handle(); inline Handle();
skipping to change at line 181 skipping to change at line 181
/** /**
* Creates a new handle for the specified value. * Creates a new handle for the specified value.
*/ */
inline explicit Handle(T* val) : val_(val) { } inline explicit Handle(T* val) : val_(val) { }
/** /**
* Creates a handle for the contents of the specified handle. This * Creates a handle for the contents of the specified handle. This
* constructor allows you to pass handles as arguments by value and * constructor allows you to pass handles as arguments by value and
* to assign between handles. However, if you try to assign between * to assign between handles. However, if you try to assign between
* incompatible handles, for instance from a Handle<String> to a * incompatible handles, for instance from a Handle<String> to a
* Handle<Number> it will cause a compiletime error. Assigning * Handle<Number> it will cause a compile-time error. Assigning
* between compatible handles, for instance assigning a * between compatible handles, for instance assigning a
* Handle<String> to a variable declared as Handle<Value>, is legal * Handle<String> to a variable declared as Handle<Value>, is legal
* because String is a subclass of Value. * because String is a subclass of Value.
*/ */
template <class S> inline Handle(Handle<S> that) template <class S> inline Handle(Handle<S> that)
: val_(reinterpret_cast<T*>(*that)) { : val_(reinterpret_cast<T*>(*that)) {
/** /**
* This check fails when trying to convert between incompatible * This check fails when trying to convert between incompatible
* handles. For example, converting from a Handle<String> to a * handles. For example, converting from a Handle<String> to a
* Handle<Number>. * Handle<Number>.
skipping to change at line 323 skipping to change at line 323
* storage cell. * storage cell.
*/ */
inline Persistent(); inline Persistent();
/** /**
* Creates a persistent handle for the same storage cell as the * Creates a persistent handle for the same storage cell as the
* specified handle. This constructor allows you to pass persistent * specified handle. This constructor allows you to pass persistent
* handles as arguments by value and to assign between persistent * handles as arguments by value and to assign between persistent
* handles. However, attempting to assign between incompatible * handles. However, attempting to assign between incompatible
* persistent handles, for instance from a Persistent<String> to a * persistent handles, for instance from a Persistent<String> to a
* Persistent<Number> will cause a compiletime error. Assigning * Persistent<Number> will cause a compile-time error. Assigning
* between compatible persistent handles, for instance assigning a * between compatible persistent handles, for instance assigning a
* Persistent<String> to a variable declared as Persistent<Value>, * Persistent<String> to a variable declared as Persistent<Value>,
* is allowed as String is a subclass of Value. * is allowed as String is a subclass of Value.
*/ */
template <class S> inline Persistent(Persistent<S> that) template <class S> inline Persistent(Persistent<S> that)
: Handle<T>(reinterpret_cast<T*>(*that)) { : Handle<T>(reinterpret_cast<T*>(*that)) {
/** /**
* This check fails when trying to convert between incompatible * This check fails when trying to convert between incompatible
* handles. For example, converting from a Handle<String> to a * handles. For example, converting from a Handle<String> to a
* Handle<Number>. * Handle<Number>.
skipping to change at line 369 skipping to change at line 369
/** /**
* Creates a new persistent handle for an existing local or * Creates a new persistent handle for an existing local or
* persistent handle. * persistent handle.
*/ */
inline static Persistent<T> New(Handle<T> that); inline static Persistent<T> New(Handle<T> that);
/** /**
* Releases the storage cell referenced by this persistent handle. * Releases the storage cell referenced by this persistent handle.
* Does not remove the reference to the cell from any handles. * Does not remove the reference to the cell from any handles.
* This handle's reference, and any any other references to the storage * This handle's reference, and any other references to the storage
* cell remain and IsEmpty will still return false. * cell remain and IsEmpty will still return false.
*/ */
inline void Dispose(); inline void Dispose();
/** /**
* Make the reference to this object weak. When only weak handles * Make the reference to this object weak. When only weak handles
* refer to the object, the garbage collector will perform a * refer to the object, the garbage collector will perform a
* callback to the given V8::WeakReferenceCallback function, passing * callback to the given V8::WeakReferenceCallback function, passing
* it the object reference and the given parameters. * it the object reference and the given parameters.
*/ */
skipping to change at line 765 skipping to change at line 765
* Returns the number of StackFrames. * Returns the number of StackFrames.
*/ */
int GetFrameCount() const; int GetFrameCount() const;
/** /**
* Returns StackTrace as a v8::Array that contains StackFrame objects. * Returns StackTrace as a v8::Array that contains StackFrame objects.
*/ */
Local<Array> AsArray(); Local<Array> AsArray();
/** /**
* Grab a snapshot of the the current JavaScript execution stack. * Grab a snapshot of the current JavaScript execution stack.
* *
* \param frame_limit The maximum number of stack frames we want to captu re. * \param frame_limit The maximum number of stack frames we want to captu re.
* \param options Enumerates the set of things we will capture for each * \param options Enumerates the set of things we will capture for each
* StackFrame. * StackFrame.
*/ */
static Local<StackTrace> CurrentStackTrace( static Local<StackTrace> CurrentStackTrace(
int frame_limit, int frame_limit,
StackTraceOptions options = kOverview); StackTraceOptions options = kOverview);
}; };
skipping to change at line 823 skipping to change at line 823
*/ */
Local<String> GetFunctionName() const; Local<String> GetFunctionName() const;
/** /**
* Returns whether or not the associated function is compiled via a call to * Returns whether or not the associated function is compiled via a call to
* eval(). * eval().
*/ */
bool IsEval() const; bool IsEval() const;
/** /**
* Returns whther or not the associated function is called as a * Returns whether or not the associated function is called as a
* constructor via "new". * constructor via "new".
*/ */
bool IsConstructor() const; bool IsConstructor() const;
}; };
// --- Value --- // --- Value ---
/** /**
* The superclass of all JavaScript values and objects. * The superclass of all JavaScript values and objects.
*/ */
skipping to change at line 1166 skipping to change at line 1166
* this function should not otherwise delete or modify the resource. Neit her * this function should not otherwise delete or modify the resource. Neit her
* should the underlying buffer be deallocated or modified except through the * should the underlying buffer be deallocated or modified except through the
* destructor of the external string resource. * destructor of the external string resource.
*/ */
V8EXPORT static Local<String> NewExternal(ExternalStringResource* resourc e); V8EXPORT static Local<String> NewExternal(ExternalStringResource* resourc e);
/** /**
* Associate an external string resource with this string by transforming it * Associate an external string resource with this string by transforming it
* in place so that existing references to this string in the JavaScript heap * in place so that existing references to this string in the JavaScript heap
* will use the external string resource. The external string resource's * will use the external string resource. The external string resource's
* character contents needs to be equivalent to this string. * character contents need to be equivalent to this string.
* Returns true if the string has been changed to be an external string. * Returns true if the string has been changed to be an external string.
* The string is not modified if the operation fails. See NewExternal for * The string is not modified if the operation fails. See NewExternal for
* information on the lifetime of the resource. * information on the lifetime of the resource.
*/ */
V8EXPORT bool MakeExternal(ExternalStringResource* resource); V8EXPORT bool MakeExternal(ExternalStringResource* resource);
/** /**
* Creates a new external string using the ascii data defined in the give n * Creates a new external string using the ascii data defined in the give n
* resource. When the external string is no longer live on V8's heap the * resource. When the external string is no longer live on V8's heap the
* resource will be disposed by calling its Dispose method. The caller of * resource will be disposed by calling its Dispose method. The caller of
skipping to change at line 1188 skipping to change at line 1188
* should the underlying buffer be deallocated or modified except through the * should the underlying buffer be deallocated or modified except through the
* destructor of the external string resource. * destructor of the external string resource.
*/ */
V8EXPORT static Local<String> NewExternal( V8EXPORT static Local<String> NewExternal(
ExternalAsciiStringResource* resource); ExternalAsciiStringResource* resource);
/** /**
* Associate an external string resource with this string by transforming it * Associate an external string resource with this string by transforming it
* in place so that existing references to this string in the JavaScript heap * in place so that existing references to this string in the JavaScript heap
* will use the external string resource. The external string resource's * will use the external string resource. The external string resource's
* character contents needs to be equivalent to this string. * character contents need to be equivalent to this string.
* Returns true if the string has been changed to be an external string. * Returns true if the string has been changed to be an external string.
* The string is not modified if the operation fails. See NewExternal for * The string is not modified if the operation fails. See NewExternal for
* information on the lifetime of the resource. * information on the lifetime of the resource.
*/ */
V8EXPORT bool MakeExternal(ExternalAsciiStringResource* resource); V8EXPORT bool MakeExternal(ExternalAsciiStringResource* resource);
/** /**
* Returns true if this string can be made external. * Returns true if this string can be made external.
*/ */
V8EXPORT bool CanMakeExternal(); V8EXPORT bool CanMakeExternal();
skipping to change at line 1516 skipping to change at line 1516
V8EXPORT bool HasIndexedLookupInterceptor(); V8EXPORT bool HasIndexedLookupInterceptor();
/** /**
* Turns on access check on the object if the object is an instance of * Turns on access check on the object if the object is an instance of
* a template that has access check callbacks. If an object has no * a template that has access check callbacks. If an object has no
* access check info, the object cannot be accessed by anyone. * access check info, the object cannot be accessed by anyone.
*/ */
V8EXPORT void TurnOnAccessCheck(); V8EXPORT void TurnOnAccessCheck();
/** /**
* Returns the identity hash for this object. The current implemenation u * Returns the identity hash for this object. The current implementation
ses * uses a hidden property on the object to store the identity hash.
* a hidden property on the object to store the identity hash.
* *
* The return value will never be 0. Also, it is not guaranteed to be * The return value will never be 0. Also, it is not guaranteed to be
* unique. * unique.
*/ */
V8EXPORT int GetIdentityHash(); V8EXPORT int GetIdentityHash();
/** /**
* Access hidden properties on JavaScript objects. These properties are * Access hidden properties on JavaScript objects. These properties are
* hidden from the executing JavaScript and only accessible through the V 8 * hidden from the executing JavaScript and only accessible through the V 8
* C++ API. Hidden properties introduced by V8 internally (for example th e * C++ API. Hidden properties introduced by V8 internally (for example th e
skipping to change at line 1598 skipping to change at line 1598
/** /**
* Call an Object as a function if a callback is set by the * Call an Object as a function if a callback is set by the
* ObjectTemplate::SetCallAsFunctionHandler method. * ObjectTemplate::SetCallAsFunctionHandler method.
*/ */
V8EXPORT Local<Value> CallAsFunction(Handle<Object> recv, V8EXPORT Local<Value> CallAsFunction(Handle<Object> recv,
int argc, int argc,
Handle<Value> argv[]); Handle<Value> argv[]);
/** /**
* Call an Object as a consturctor if a callback is set by the * Call an Object as a constructor if a callback is set by the
* ObjectTemplate::SetCallAsFunctionHandler method. * ObjectTemplate::SetCallAsFunctionHandler method.
* Note: This method behaves like the Function::NewInstance method. * Note: This method behaves like the Function::NewInstance method.
*/ */
V8EXPORT Local<Value> CallAsConstructor(int argc, V8EXPORT Local<Value> CallAsConstructor(int argc,
Handle<Value> argv[]); Handle<Value> argv[]);
V8EXPORT static Local<Object> New(); V8EXPORT static Local<Object> New();
static inline Object* Cast(Value* obj); static inline Object* Cast(Value* obj);
private: private:
V8EXPORT Object(); V8EXPORT Object();
skipping to change at line 2198 skipping to change at line 2198
/** /**
* Sets an indexed property handler on the object template. * Sets an indexed property handler on the object template.
* *
* Whenever an indexed property is accessed on objects created from * Whenever an indexed property is accessed on objects created from
* this object template, the provided callback is invoked instead of * this object template, the provided callback is invoked instead of
* accessing the property directly on the JavaScript object. * accessing the property directly on the JavaScript object.
* *
* \param getter The callback to invoke when getting a property. * \param getter The callback to invoke when getting a property.
* \param setter The callback to invoke when setting a property. * \param setter The callback to invoke when setting a property.
* \param query The callback to invoke to check is an object has a proper ty. * \param query The callback to invoke to check if an object has a proper ty.
* \param deleter The callback to invoke when deleting a property. * \param deleter The callback to invoke when deleting a property.
* \param enumerator The callback to invoke to enumerate all the indexed * \param enumerator The callback to invoke to enumerate all the indexed
* properties of an object. * properties of an object.
* \param data A piece of data that will be passed to the callbacks * \param data A piece of data that will be passed to the callbacks
* whenever they are invoked. * whenever they are invoked.
*/ */
void SetIndexedPropertyHandler(IndexedPropertyGetter getter, void SetIndexedPropertyHandler(IndexedPropertyGetter getter,
IndexedPropertySetter setter = 0, IndexedPropertySetter setter = 0,
IndexedPropertyQuery query = 0, IndexedPropertyQuery query = 0,
IndexedPropertyDeleter deleter = 0, IndexedPropertyDeleter deleter = 0,
skipping to change at line 2642 skipping to change at line 2642
static void SetAllowCodeGenerationFromStringsCallback( static void SetAllowCodeGenerationFromStringsCallback(
AllowCodeGenerationFromStringsCallback that); AllowCodeGenerationFromStringsCallback that);
/** /**
* Ignore out-of-memory exceptions. * Ignore out-of-memory exceptions.
* *
* V8 running out of memory is treated as a fatal error by default. * 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 * This means that the fatal error handler is called and that V8 is
* terminated. * terminated.
* *
* IgnoreOutOfMemoryException can be used to not treat a * IgnoreOutOfMemoryException can be used to not treat an
* out-of-memory situation as a fatal error. This way, the contexts * 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 * that did not cause the out of memory problem might be able to
* continue execution. * continue execution.
*/ */
static void IgnoreOutOfMemoryException(); static void IgnoreOutOfMemoryException();
/** /**
* Check if V8 is dead and therefore unusable. This is the case after * Check if V8 is dead and therefore unusable. This is the case after
* fatal errors such as out-of-memory situations. * fatal errors such as out-of-memory situations.
*/ */
skipping to change at line 2678 skipping to change at line 2678
* ... make sure the decompressed data stays valid until V8 shutdown * ... make sure the decompressed data stays valid until V8 shutdown
*/ */
static StartupData::CompressionAlgorithm GetCompressedStartupDataAlgorith m(); static StartupData::CompressionAlgorithm GetCompressedStartupDataAlgorith m();
static int GetCompressedStartupDataCount(); static int GetCompressedStartupDataCount();
static void GetCompressedStartupData(StartupData* compressed_data); static void GetCompressedStartupData(StartupData* compressed_data);
static void SetDecompressedStartupData(StartupData* decompressed_data); static void SetDecompressedStartupData(StartupData* decompressed_data);
/** /**
* Adds a message listener. * Adds a message listener.
* *
* The same message listener can be added more than once and it that * The same message listener can be added more than once and in that
* case it will be called more than once for each message. * case it will be called more than once for each message.
*/ */
static bool AddMessageListener(MessageCallback that, static bool AddMessageListener(MessageCallback that,
Handle<Value> data = Handle<Value>()); Handle<Value> data = Handle<Value>());
/** /**
* Remove all message listeners from the specified callback function. * Remove all message listeners from the specified callback function.
*/ */
static void RemoveMessageListeners(MessageCallback that); static void RemoveMessageListeners(MessageCallback that);
skipping to change at line 2958 skipping to change at line 2958
* *
* TerminateExecution should only be called when then V8 lock has * TerminateExecution should only be called when then V8 lock has
* been acquired with a Locker object. Therefore, in order to be * been acquired with a Locker object. Therefore, in order to be
* able to terminate long-running threads, preemption must be * able to terminate long-running threads, preemption must be
* enabled to allow the user of TerminateExecution to acquire the * enabled to allow the user of TerminateExecution to acquire the
* lock. * lock.
* *
* The termination is achieved by throwing an exception that is * The termination is achieved by throwing an exception that is
* uncatchable by JavaScript exception handlers. Termination * uncatchable by JavaScript exception handlers. Termination
* exceptions act as if they were caught by a C++ TryCatch exception * exceptions act as if they were caught by a C++ TryCatch exception
* handlers. If forceful termination is used, any C++ TryCatch * handler. If forceful termination is used, any C++ TryCatch
* exception handler that catches an exception should check if that * exception handler that catches an exception should check if that
* exception is a termination exception and immediately return if * exception is a termination exception and immediately return if
* that is the case. Returning immediately in that case will * that is the case. Returning immediately in that case will
* continue the propagation of the termination exception if needed. * continue the propagation of the termination exception if needed.
* *
* The thread id passed to TerminateExecution must have been * The thread id passed to TerminateExecution must have been
* obtained by calling GetCurrentThreadId on the thread in question. * obtained by calling GetCurrentThreadId on the thread in question.
* *
* \param thread_id The thread id of the thread to terminate. * \param thread_id The thread id of the thread to terminate.
*/ */
skipping to change at line 3357 skipping to change at line 3357
* ... * ...
* { * {
* v8::Locker locker(isolate); * v8::Locker locker(isolate);
* v8::Isolate::Scope isolate_scope(isolate); * v8::Isolate::Scope isolate_scope(isolate);
* ... * ...
* // Code using V8 and isolate goes here. * // Code using V8 and isolate goes here.
* ... * ...
* } // Destructor called here * } // Destructor called here
* \endcode * \endcode
* *
* If you wish to stop using V8 in a thread A you can do this by either * If you wish to stop using V8 in a thread A you can do this either
* by destroying the v8::Locker object as above or by constructing a * by destroying the v8::Locker object as above or by constructing a
* v8::Unlocker object: * v8::Unlocker object:
* *
* \code * \code
* { * {
* isolate->Exit(); * isolate->Exit();
* v8::Unlocker unlocker(isolate); * v8::Unlocker unlocker(isolate);
* ... * ...
* // Code not using V8 goes here while V8 can run in another thread. * // Code not using V8 goes here while V8 can run in another thread.
* ... * ...
skipping to change at line 3432 skipping to change at line 3432
public: public:
/** /**
* Initialize Locker for a given Isolate. NULL means default isolate. * Initialize Locker for a given Isolate. NULL means default isolate.
*/ */
explicit Locker(Isolate* isolate = NULL); explicit Locker(Isolate* isolate = NULL);
~Locker(); ~Locker();
/** /**
* Start preemption. * Start preemption.
* *
* When preemption is started, a timer is fired every n milli seconds * When preemption is started, a timer is fired every n milliseconds
* that will switch between multiple threads that are in contention * that will switch between multiple threads that are in contention
* for the V8 lock. * for the V8 lock.
*/ */
static void StartPreemption(int every_n_ms); static void StartPreemption(int every_n_ms);
/** /**
* Stop preemption. * Stop preemption.
*/ */
static void StopPreemption(); static void StopPreemption();
skipping to change at line 3608 skipping to change at line 3608
static const int kHeapObjectMapOffset = 0; static const int kHeapObjectMapOffset = 0;
static const int kMapInstanceTypeOffset = 1 * kApiPointerSize + kApiIntSi ze; static const int kMapInstanceTypeOffset = 1 * kApiPointerSize + kApiIntSi ze;
static const int kStringResourceOffset = static const int kStringResourceOffset =
InternalConstants<kApiPointerSize>::kStringResourceOffset; InternalConstants<kApiPointerSize>::kStringResourceOffset;
static const int kProxyProxyOffset = kApiPointerSize; static const int kProxyProxyOffset = kApiPointerSize;
static const int kJSObjectHeaderSize = 3 * kApiPointerSize; static const int kJSObjectHeaderSize = 3 * kApiPointerSize;
static const int kFullStringRepresentationMask = 0x07; static const int kFullStringRepresentationMask = 0x07;
static const int kExternalTwoByteRepresentationTag = 0x02; static const int kExternalTwoByteRepresentationTag = 0x02;
static const int kJSObjectType = 0xa1; static const int kJSObjectType = 0xa2;
static const int kFirstNonstringType = 0x80; static const int kFirstNonstringType = 0x80;
static const int kProxyType = 0x85; static const int kProxyType = 0x85;
static inline bool HasHeapObjectTag(internal::Object* value) { static inline bool HasHeapObjectTag(internal::Object* value) {
return ((reinterpret_cast<intptr_t>(value) & kHeapObjectTagMask) == return ((reinterpret_cast<intptr_t>(value) & kHeapObjectTagMask) ==
kHeapObjectTag); kHeapObjectTag);
} }
static inline bool HasSmiTag(internal::Object* value) { static inline bool HasSmiTag(internal::Object* value) {
return ((reinterpret_cast<intptr_t>(value) & kSmiTagMask) == kSmiTag); return ((reinterpret_cast<intptr_t>(value) & kSmiTagMask) == kSmiTag);
 End of changes. 17 change blocks. 
19 lines changed or deleted 18 lines changed or added

This html diff was produced by rfcdiff 1.41. The latest version is available from http://tools.ietf.org/tools/rfcdiff/