v8-profiler.h   v8-profiler.h 
skipping to change at line 244 skipping to change at line 244
/** Returns destination node. */ /** Returns destination node. */
const HeapGraphNode* GetToNode() const; const HeapGraphNode* GetToNode() const;
}; };
/** /**
* HeapGraphNode represents a node in a heap graph. * HeapGraphNode represents a node in a heap graph.
*/ */
class V8_EXPORT HeapGraphNode { class V8_EXPORT HeapGraphNode {
public: public:
enum Type { enum Type {
kHidden = 0, // Hidden node, may be filtered when shown to user. kHidden = 0, // Hidden node, may be filtered when shown to user.
kArray = 1, // An array of elements. kArray = 1, // An array of elements.
kString = 2, // A string. kString = 2, // A string.
kObject = 3, // A JS object (except for arrays and strings). kObject = 3, // A JS object (except for arrays and strings).
kCode = 4, // Compiled code. kCode = 4, // Compiled code.
kClosure = 5, // Function closure. kClosure = 5, // Function closure.
kRegExp = 6, // RegExp. kRegExp = 6, // RegExp.
kHeapNumber = 7, // Number stored in the heap. kHeapNumber = 7, // Number stored in the heap.
kNative = 8, // Native object (not from V8 heap). kNative = 8, // Native object (not from V8 heap).
kSynthetic = 9 // Synthetic object, usualy used for grouping kSynthetic = 9, // Synthetic object, usualy used for grouping
// snapshot items together. // snapshot items together.
kConsString = 10, // Concatenated string. A pair of pointers to strin
gs.
kSlicedString = 11 // Sliced string. A fragment of another string.
}; };
/** Returns node type (see HeapGraphNode::Type). */ /** Returns node type (see HeapGraphNode::Type). */
Type GetType() const; Type GetType() const;
/** /**
* Returns node name. Depending on node's type this can be the name * Returns node name. Depending on node's type this can be the name
* of the constructor (for objects), the name of the function (for * of the constructor (for objects), the name of the function (for
* closures), string value, or an empty string (for compiled code). * closures), string value, or an empty string (for compiled code).
*/ */
 End of changes. 1 change blocks. 
11 lines changed or deleted 14 lines changed or added


 v8.h   v8.h 
skipping to change at line 538 skipping to change at line 538
} }
V8_INLINE(Persistent& operator=(const Persistent& that)) { // NOLINT V8_INLINE(Persistent& operator=(const Persistent& that)) { // NOLINT
Copy(that); Copy(that);
return *this; return *this;
} }
template <class S, class M2> template <class S, class M2>
V8_INLINE(Persistent& operator=(const Persistent<S, M2>& that)) { // NOLI NT V8_INLINE(Persistent& operator=(const Persistent<S, M2>& that)) { // NOLI NT
Copy(that); Copy(that);
return *this; return *this;
} }
/**
* The destructor will dispose the Persistent based on the
* kResetInDestructor flags in the traits class. Since not calling dispo
se
* can result in a memory leak, it is recommended to always set this flag
.
*/
V8_INLINE(~Persistent()) {
if (M::kResetInDestructor) Reset();
}
/** /**
* If non-empty, destroy the underlying storage cell * If non-empty, destroy the underlying storage cell
* IsEmpty() will return true after this call. * IsEmpty() will return true after this call.
*/ */
V8_INLINE(void Reset()); V8_INLINE(void Reset());
template <class S> template <class S>
/** /**
* If non-empty, destroy the underlying storage cell * If non-empty, destroy the underlying storage cell
* and create a new one with the contents of other if other is non empty * and create a new one with the contents of other if other is non empty
skipping to change at line 742 skipping to change at line 750
* place in the new handle scope until it is deleted. After that, * place in the new handle scope until it is deleted. After that,
* new handles will again be allocated in the original handle scope. * new handles will again be allocated in the original handle scope.
* *
* After the handle scope of a local handle has been deleted the * After the handle scope of a local handle has been deleted the
* garbage collector will no longer track the object stored in the * garbage collector will no longer track the object stored in the
* handle and may deallocate it. The behavior of accessing a handle * handle and may deallocate it. The behavior of accessing a handle
* for which the handle scope has been deleted is undefined. * for which the handle scope has been deleted is undefined.
*/ */
class V8_EXPORT HandleScope { class V8_EXPORT HandleScope {
public: public:
// TODO(svenpanne) Deprecate me when Chrome is fixed!
HandleScope();
HandleScope(Isolate* isolate); HandleScope(Isolate* isolate);
~HandleScope(); ~HandleScope();
/** /**
* Closes the handle scope and returns the value as a handle in the * Closes the handle scope and returns the value as a handle in the
* previous scope, which is the new current scope after the call. * previous scope, which is the new current scope after the call.
*/ */
template <class T> Local<T> Close(Handle<T> value); template <class T> Local<T> Close(Handle<T> value);
skipping to change at line 805 skipping to change at line 810
internal::Object** prev_limit_; internal::Object** prev_limit_;
// Allow for the active closing of HandleScopes which allows to pass a ha ndle // Allow for the active closing of HandleScopes which allows to pass a ha ndle
// from the HandleScope being closed to the next top most HandleScope. // from the HandleScope being closed to the next top most HandleScope.
bool is_closed_; bool is_closed_;
internal::Object** RawClose(internal::Object** value); internal::Object** RawClose(internal::Object** value);
friend class ImplementationUtilities; friend class ImplementationUtilities;
}; };
/**
* A simple Maybe type, representing an object which may or may not have a
* value.
*/
template<class T>
struct Maybe {
Maybe() : has_value(false) {}
explicit Maybe(T t) : has_value(true), value(t) {}
Maybe(bool has, T t) : has_value(has), value(t) {}
bool has_value;
T value;
};
// --- Special objects --- // --- Special objects ---
/** /**
* The superclass of values and API object templates. * The superclass of values and API object templates.
*/ */
class V8_EXPORT Data { class V8_EXPORT Data {
private: private:
Data(); Data();
}; };
skipping to change at line 3657 skipping to change at line 3676
ResourceConstraints(); ResourceConstraints();
int max_young_space_size() const { return max_young_space_size_; } int max_young_space_size() const { return max_young_space_size_; }
void set_max_young_space_size(int value) { max_young_space_size_ = value; } void set_max_young_space_size(int value) { max_young_space_size_ = value; }
int max_old_space_size() const { return max_old_space_size_; } int max_old_space_size() const { return max_old_space_size_; }
void set_max_old_space_size(int value) { max_old_space_size_ = value; } void set_max_old_space_size(int value) { max_old_space_size_ = value; }
int max_executable_size() { return max_executable_size_; } int max_executable_size() { return max_executable_size_; }
void set_max_executable_size(int value) { max_executable_size_ = value; } void set_max_executable_size(int value) { max_executable_size_ = value; }
uint32_t* stack_limit() const { return stack_limit_; } uint32_t* stack_limit() const { return stack_limit_; }
// Sets an address beyond which the VM's stack may not grow. // Sets an address beyond which the VM's stack may not grow.
void set_stack_limit(uint32_t* value) { stack_limit_ = value; } void set_stack_limit(uint32_t* value) { stack_limit_ = value; }
Maybe<bool> is_memory_constrained() const { return is_memory_constrained_
; }
// If set to true, V8 will limit it's memory usage, at the potential cost
of
// lower performance. Note, this option is a tentative addition to the A
PI
// and may be removed or modified without warning.
void set_memory_constrained(bool value) {
is_memory_constrained_ = Maybe<bool>(value);
}
private: private:
int max_young_space_size_; int max_young_space_size_;
int max_old_space_size_; int max_old_space_size_;
int max_executable_size_; int max_executable_size_;
uint32_t* stack_limit_; uint32_t* stack_limit_;
Maybe<bool> is_memory_constrained_;
}; };
bool V8_EXPORT SetResourceConstraints(ResourceConstraints* constraints); bool V8_EXPORT SetResourceConstraints(ResourceConstraints* constraints);
// --- Exceptions --- // --- Exceptions ---
typedef void (*FatalErrorCallback)(const char* location, const char* messag e); typedef void (*FatalErrorCallback)(const char* location, const char* messag e);
typedef void (*MessageCallback)(Handle<Message> message, Handle<Value> erro r); typedef void (*MessageCallback)(Handle<Message> message, Handle<Value> erro r);
 End of changes. 5 change blocks. 
3 lines changed or deleted 36 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/