Lines Matching refs:that
2 // Use of this source code is governed by a BSD-style license that can be
32 build configuration to ensure that at most one of these is set
177 * collector so that it knows that the objects are still alive. Also,
215 template <class S> V8_INLINE Handle(Handle<S> that)
216 : val_(reinterpret_cast<T*>(*that)) {
245 template <class S> V8_INLINE bool operator==(const Handle<S>& that) const {
247 internal::Object** b = reinterpret_cast<internal::Object**>(that.val_);
254 const PersistentBase<S>& that) const {
256 internal::Object** b = reinterpret_cast<internal::Object**>(that.val_);
268 template <class S> V8_INLINE bool operator!=(const Handle<S>& that) const {
269 return !operator==(that);
273 const Persistent<S>& that) const {
274 return !operator==(that);
277 template <class S> V8_INLINE static Handle<T> Cast(Handle<S> that) {
280 // that the handle isn't empty before doing the checked cast.
281 if (that.IsEmpty()) return Handle<T>();
283 return Handle<T>(T::Cast(*that));
290 V8_INLINE static Handle<T> New(Isolate* isolate, Handle<T> that) {
291 return New(isolate, that.val_);
294 const PersistentBase<T>& that) {
295 return New(isolate, that.val_);
321 V8_INLINE static Handle<T> New(Isolate* isolate, T* that);
329 * that return objects from within v8 return them in local handles. They
337 template <class S> V8_INLINE Local(Local<S> that)
338 : Handle<T>(reinterpret_cast<T*>(*that)) {
348 template <class S> V8_INLINE static Local<T> Cast(Local<S> that) {
351 // that the handle isn't empty before doing the checked cast.
352 if (that.IsEmpty()) return Local<T>();
354 return Local<T>(T::Cast(*that));
356 template <class S> V8_INLINE Local(Handle<S> that)
357 : Handle<T>(reinterpret_cast<T*>(*that)) {
370 V8_INLINE static Local<T> New(Isolate* isolate, Handle<T> that);
372 const PersistentBase<T>& that);
392 template <class S> V8_INLINE Local(S* that) : Handle<T>(that) { }
393 V8_INLINE static Local<T> New(Isolate* isolate, T* that);
397 // Eternal handles are set-once handles that live for the life of the isolate.
436 * An object reference that is independent of any handle scope. Where
472 V8_INLINE bool operator==(const PersistentBase<S>& that) const {
474 internal::Object** b = reinterpret_cast<internal::Object**>(that.val_);
480 template <class S> V8_INLINE bool operator==(const Handle<S>& that) const {
482 internal::Object** b = reinterpret_cast<internal::Object**>(that.val_);
489 V8_INLINE bool operator!=(const PersistentBase<S>& that) const {
490 return !operator==(that);
493 template <class S> V8_INLINE bool operator!=(const Handle<S>& that) const {
494 return !operator==(that);
523 * independent handle should not assume that it will be preceded by a global
532 * smaller object groups for young objects that represent only a subset of all
574 V8_INLINE static T* New(Isolate* isolate, T* that);
583 * At present kResetInDestructor is not set, but that will change in a future
638 template <class S> V8_INLINE Persistent(Isolate* isolate, Handle<S> that)
639 : PersistentBase<T>(PersistentBase<T>::New(isolate, *that)) {
648 V8_INLINE Persistent(Isolate* isolate, const Persistent<S, M2>& that)
649 : PersistentBase<T>(PersistentBase<T>::New(isolate, *that)) {
658 V8_INLINE Persistent(const Persistent& that) : PersistentBase<T>(0) {
659 Copy(that);
662 V8_INLINE Persistent(const Persistent<S, M2>& that) : PersistentBase<T>(0) {
663 Copy(that);
665 V8_INLINE Persistent& operator=(const Persistent& that) { // NOLINT
666 Copy(that);
670 V8_INLINE Persistent& operator=(const Persistent<S, M2>& that) { // NOLINT
671 Copy(that);
685 V8_INLINE static Persistent<T>& Cast(Persistent<S>& that) { // NOLINT
688 // that the handle isn't empty before doing the checked cast.
689 if (!that.IsEmpty()) T::Cast(*that);
691 return reinterpret_cast<Persistent<T>&>(that);
710 template <class S> V8_INLINE Persistent(S* that) : PersistentBase<T>(that) { }
713 V8_INLINE void Copy(const Persistent<S, M2>& that);
740 V8_INLINE UniquePersistent(Isolate* isolate, Handle<S> that)
741 : PersistentBase<T>(PersistentBase<T>::New(isolate, *that)) {
750 V8_INLINE UniquePersistent(Isolate* isolate, const PersistentBase<S>& that)
751 : PersistentBase<T>(PersistentBase<T>::New(isolate, that.val_)) {
789 * A stack-allocated class that governs a number of local handles.
791 * allocated within that handle scope until either the handle scope is
794 * place in the new handle scope until it is deleted. After that,
1022 * Compilation data that the embedder can cache and pass back to speed up
1037 // data and guarantees that it stays alive until the CachedData object is
1175 * Note that when producing cached data, the source must point to NULL for
1194 * \return Compiled script object, bound to the context that was active
1309 * Flags that determine what information is placed captured for each
1337 * Returns StackTrace as a v8::Array that contains StackFrame objects.
1386 * Returns the name of the resource that contains the script for the
1392 * Returns the name of the resource that contains the script for the
1693 bool Equals(Handle<Value> that) const;
1694 bool StrictEquals(Handle<Value> that) const;
1695 bool SameValue(Handle<Value> that) const;
1791 * \param options Various options that might affect performance of this or
1868 * buffer that resides outside V8's heap. Implement an
1870 * buffer. Note that the string data must be immutable.
1897 * string buffer that resides outside V8's heap. Implement an
1899 * underlying buffer. Note that the string data must be immutable
1900 * and that the data must be Latin-1 and not UTF-8, which would require
1993 * in place so that existing references to this string in the JavaScript heap
2015 * in place so that existing references to this string in the JavaScript heap
2097 // Note that symbols created this way are never collected, so
2104 // registry that is not accessible by (and cannot clash with) JavaScript code.
2135 // Note that private symbols created this way are never collected, so
2256 * the kind of cross-context access that should be allowed.
2280 // Note that if the object has an interceptor the property will be set
2284 // Note also that this only works for named properties.
2390 * This is different from Value::ToString() that may call
2462 * a template that has access check callbacks. If an object has no
2489 * been modified since it was created. Note that this method is
2490 * conservative and may return true for objects that haven't actually
2510 * Note: The embedding program still owns the data and needs to ensure that
2522 * Note: The embedding program still owns the data and needs to ensure that
2596 template <class S> V8_INLINE ReturnValue(const ReturnValue<S>& that)
2597 : value_(that.value_) {
2841 * Allocator that V8 uses to allocate |ArrayBuffer|'s memory.
2875 * Allocator::Allocate that is set with V8::SetArrayBufferAllocator.
2917 * Returns true if ArrayBuffer is extrenalized, that is, does not
2937 * that has been set with V8::SetArrayBufferAllocator.
3177 * A specialization of Value::NumberValue that is more efficient
3185 * Notification that the embedder has changed the time zone,
3189 * those cached values for the current context so that date /
3316 * A JavaScript value that wraps a C++ void*. This type of value is mainly used
3358 * \param data A piece of data that will be passed to the getter and setter
3364 * ALL_CAN_READ means that all cross-context reads are allowed.
3365 * ALL_CAN_WRITE means that all cross-context writes are allowed.
3541 * temporary functions that can be collected using Scripts is
3737 * \param data A piece of data that will be passed to the getter and setter
3743 * ALL_CAN_READ means that all cross-context reads are allowed.
3744 * ALL_CAN_WRITE means that all cross-context writes are allowed.
3786 * \param data A piece of data that will be passed to the callbacks
3810 * \param data A piece of data that will be passed to the callbacks
3824 * behave like normal JavaScript objects that cannot be called as a
3998 // Note that the strings passed into this constructor must live as long
4046 * A set of constraints that specifies the limits of the runtime's memory use.
4244 * \param function the address of the function that's being entered.
4290 // Name of the object associated with the code, note that the string is not
4357 * address of a function that's invoked on entry to every V8-generated
4358 * function. Note that entry_hook is invoked at the very start of each
4365 * Allows the host application to provide the address of a function that is
4404 * Assert that no Javascript code is invoked.
4461 * Types of garbage collections that can be requested via
4507 * Saves the previously entered one (if any), so that it can be
4552 * indication of the amount of externally allocated memory that is kept alive
4556 * to garbage collect the JavaScript objects that keep the externally
4559 * \param change_in_bytes the change in externally allocated memory that is
4582 /** Returns the context that is on the top of the stack. */
4710 void SetEventLogger(LogEventCallback that);
4722 * Removes callback that was installed by AddCallCompletedCallback.
4775 * Optional notification that the embedder is idle.
4779 * until real work has been done. This indicates that V8 has done
4783 * the memory footprint. There is no guarantee that the actual work will be
4789 * Optional notification that the system is running low on memory.
4795 * Optional notification that a context has been disposed. V8 uses
4803 * Allows the host application to provide the address of a function that is
4811 * \p event_handler may get notifications of code that overlaps earlier
4901 * resolving the location of a return address on the stack. Profilers that
4943 static void SetFatalErrorHandler(FatalErrorCallback that);
4950 AllowCodeGenerationFromStringsCallback that);
5011 * The same message listener can be added more than once and in that
5017 static bool AddMessageListener(MessageCallback that,
5023 static void RemoveMessageListeners(MessageCallback that);
5099 * Removes callback that was installed by AddMemoryAllocationCallback.
5116 * Allows the host application to provide a callback that allows v8 to
5117 * cooperate with a profiler that rewrites return addresses on stack.
5126 * This method can be used by any thread even if that thread has not
5137 * because of a call to TerminateExecution. In that case there are
5156 * This method can be used by any thread even if that thread has not
5165 * that may be running. Note that disposing v8 is permanent, it
5177 * guarantee that visited objects are still alive.
5183 * that have class_ids.
5189 * that have class_ids and are candidates to be marked as partially dependent
5250 * Creates a new try/catch block and registers it with v8. Note that
5285 * indicating that it is possible to call CancelTerminateExecution in order
5291 * Throws the exception caught by this TryCatch in a way that avoids
5323 * Clears any exceptions that may have been caught by this try/catch block.
5337 * By default, exceptions that are caught by an external exception
5357 * This method returns address that can be used for comparisons with
5426 * that way for security reasons (for more details see
5429 * Please note that changes to global proxy object prototype most probably
5487 * context that was in place when entering the current context.
5496 * previous call to SetEmbedderData with the same index. Note that index 0
5503 * needed. Note that index 0 currently has a special meaning for Chrome's
5511 * SetAlignedPointerInEmbedderData with the same index. Note that index 0
5518 * index, growing the data as needed. Note that index 0 currently has a
5532 * constructor. If that callback returns true, the call will be
5545 * Sets the error description for the exception that is thrown when
5582 * It is up to the user of V8 to ensure, perhaps with locking, that this
5584 * mechanism that may be used, the v8::Locker and v8::Unlocker classes must be
5589 * isolate. V8 guarantees that an isolate can be locked by at most one thread at
5623 * given thread. This can be useful if you have code that can be called either
5624 * from code that holds the lock or from code that does not. The Unlocker is
5626 * you can not use an Unlocker in a thread that is not inside a Locker's scope.
5787 * This class exports constants and functionality from within v8 that
5826 // to avoid that resource-constrained embedders run low on memory.
5875 // Map::InstanceType is defined so that it will always be loaded into
5963 Local<T> Local<T>::New(Isolate* isolate, Handle<T> that) {
5964 return New(isolate, that.val_);
5968 Local<T> Local<T>::New(Isolate* isolate, const PersistentBase<T>& that) {
5969 return New(isolate, that.val_);
5973 Handle<T> Handle<T>::New(Isolate* isolate, T* that) {
5974 if (that == NULL) return Handle<T>();
5975 T* that_ptr = that;
5983 Local<T> Local<T>::New(Isolate* isolate, T* that) {
5984 if (that == NULL) return Local<T>();
5985 T* that_ptr = that;
6007 T* PersistentBase<T>::New(Isolate* isolate, T* that) {
6008 if (that == NULL) return NULL;
6009 internal::Object** p = reinterpret_cast<internal::Object**>(that);
6018 void Persistent<T, M>::Copy(const Persistent<S, M2>& that) {
6021 if (that.IsEmpty()) return;
6022 internal::Object** p = reinterpret_cast<internal::Object**>(that.val_);
6024 M::Copy(that, this);
6942 * A simple shell that takes a list of expressions on the