Various API changes

include/v8.h

 // Copyright 2007-2008 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 110 matching lines @@
 
 // --- W e a k  H a n d l e s
 
 
 /**
  * A weak reference callback function.
  *
  * \param object the weak global object to be reclaimed by the garbage collector
  * \param parameter the value passed in when making the weak global object
  */
-typedef void (*WeakReferenceCallback)(Persistent<Object> object,
+typedef void (*WeakReferenceCallback)(Persistent<Value> object,
                                       void* parameter);
 
 
 // --- H a n d l e s ---
 
 #define TYPE_CHECK(T, S)                              \
   while (false) {                                     \
     *(static_cast<T**>(0)) = static_cast<S*>(0);      \
   }
 
@@ skipping 363 matching lines @@
  * The origin, within a file, of a script.
  */
 class EXPORT ScriptOrigin {
  public:
   ScriptOrigin(Handle<Value> resource_name,
                Handle<Integer> resource_line_offset = Handle<Integer>(),
                Handle<Integer> resource_column_offset = Handle<Integer>())
       : resource_name_(resource_name),
         resource_line_offset_(resource_line_offset),
         resource_column_offset_(resource_column_offset) { }
-  inline Handle<Value> ResourceName();
-  inline Handle<Integer> ResourceLineOffset();
-  inline Handle<Integer> ResourceColumnOffset();
+  inline Handle<Value> ResourceName() const;
+  inline Handle<Integer> ResourceLineOffset() const;
+  inline Handle<Integer> ResourceColumnOffset() const;
  private:
   Handle<Value> resource_name_;
   Handle<Integer> resource_line_offset_;
   Handle<Integer> resource_column_offset_;
 };
 
 
 /**
  * A compiled JavaScript script.
  */
@@ skipping 24 matching lines @@
 
 
 /**
  * An error message.
  */
 class EXPORT Message {
  public:
   Local<String> Get();
   Local<String> GetSourceLine();
 
-  // TODO(1241256): Rewrite (or remove) this method.  We don't want to
-  // deal with ownership of the returned string and we want to use
-  // JavaScript data structures exclusively.
-  char* GetUnderline(char* source_line, char underline_char);
-
-  Handle<String> GetScriptResourceName();
-
-  // TODO(1240903): Remove this when no longer used in WebKit V8
-  // bindings.
-  Handle<Value> GetSourceData();
+  Handle<Value> GetScriptResourceName();
 
   /**
    * Returns the number, 1-based, of the line where the error occurred.
    */
   int GetLineNumber();
 
   /**
    * Returns the index within the script of the first character where
    * the error occurred.
    */
@@ skipping 87 matching lines @@
   /**
    * Returns true if this value is external.
    */
   bool IsExternal();
 
   /**
    * Returns true if this value is a 32-bit signed integer.
    */
   bool IsInt32();
 
+  /**
+   * Returns true if this value is a Date.
+   */
+  bool IsDate();
+
   Local<Boolean> ToBoolean();
   Local<Number> ToNumber();
   Local<String> ToString();
   Local<String> ToDetailString();
   Local<Object> ToObject();
   Local<Integer> ToInteger();
   Local<Uint32> ToUint32();
   Local<Int32> ToInt32();
 
   /**
@@ skipping 295 matching lines @@
   Uint32();
 };
 
 
 /**
  * An instance of the built-in Date constructor (ECMA-262, 15.9).
  */
 class EXPORT Date : public Value {
  public:
   static Local<Value> New(double time);
+
+  /**
+   * A specialization of Value::NumberValue that is more efficient
+   * because we know the structure of this object.
+   */
+  double NumberValue();
+
+  static Date* Cast(v8::Value* obj);
 };
 
 
 enum PropertyAttribute {
   None       = 0,
   ReadOnly   = 1 << 0,
   DontEnum   = 1 << 1,
   DontDelete = 1 << 2
 };
 
@@ skipping 734 matching lines @@
 Handle<Boolean> EXPORT False();
 
 
 /**
  * A set of constraints that specifies the limits of the runtime's
  * memory use.
  */
 class EXPORT ResourceConstraints {
  public:
   ResourceConstraints();
-  int max_young_space_size() { 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; }
-  int max_old_space_size() { 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; }
-  uint32_t* stack_limit() { return stack_limit_; }
+  uint32_t* stack_limit() const { return stack_limit_; }
   void set_stack_limit(uint32_t* value) { stack_limit_ = value; }
  private:
   int max_young_space_size_;
   int max_old_space_size_;
   uint32_t* stack_limit_;
 };
 
 
 bool SetResourceConstraints(ResourceConstraints* constraints);
 
@@ skipping 210 matching lines @@
   TryCatch();
 
   /**
    * Unregisters and deletes this try/catch block.
    */
   ~TryCatch();
 
   /**
    * Returns true if an exception has been caught by this try/catch block.
    */
-  bool HasCaught();
+  bool HasCaught() const;
 
   /**
    * Returns the exception caught by this try/catch block.  If no exception has
    * been caught an empty handle is returned.
    *
    * The returned handle is valid until this TryCatch block has been destroyed.
    */
-  Local<Value> Exception();
+  Local<Value> Exception() const;
 
   /**
    * Returns the message associated with this exception.  If there is
    * no message associated an empty handle is returned.
    *
    * The returned handle is valid until this TryCatch block has been
    * destroyed.
    */
-  Local<v8::Message> Message();
+  Local<v8::Message> Message() const;
 
   /**
    * Clears any exceptions that may have been caught by this try/catch block.
    * After this method has been called, HasCaught() will return false.
    *
    * It is not necessary to clear a try/catch block before using it again; if
    * another exception is thrown the previously caught exception will just be
    * overwritten.  However, it is often a good idea since it makes it easier
    * to determine which operation threw a given exception.
    */
@@ skipping 355 matching lines @@
   return holder_;
 }
 
 
 template <class T>
 Local<T> HandleScope::Close(Handle<T> value) {
   void** after = RawClose(reinterpret_cast<void**>(*value));
   return Local<T>(reinterpret_cast<T*>(after));
 }
 
-Handle<Value> ScriptOrigin::ResourceName() {
+Handle<Value> ScriptOrigin::ResourceName() const {
   return resource_name_;
 }
 
 
-Handle<Integer> ScriptOrigin::ResourceLineOffset() {
+Handle<Integer> ScriptOrigin::ResourceLineOffset() const {
   return resource_line_offset_;
 }
 
 
-Handle<Integer> ScriptOrigin::ResourceColumnOffset() {
+Handle<Integer> ScriptOrigin::ResourceColumnOffset() const {
   return resource_column_offset_;
 }
 
 
 Handle<Boolean> Boolean::New(bool value) {
   return value ? True() : False();
 }
 
 
 void Template::Set(const char* name, v8::Handle<Data> value) {
@@ skipping 15 matching lines @@
 
 }  // namespace v8
 
 
 #undef EXPORT
 #undef EXPORT_INLINE
 #undef TYPE_CHECK
 
 
 #endif  // V8_H_