Mark deprecated APIs with relatively little use as deprecated

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 1222 matching lines @@
   int GetEndColumn() const;
 
   /**
    * Passes on the value set by the embedder when it fed the script from which
    * this Message was generated to V8.
    */
   bool IsSharedCrossOrigin() const;
 
   // TODO(1245381): Print to a string instead of on a FILE.
   static void PrintCurrentStackTrace(Isolate* isolate, FILE* out);
-  // Will be deprecated soon.
-  static void PrintCurrentStackTrace(FILE* out);
+  V8_DEPRECATED("Will be removed",
+                static void PrintCurrentStackTrace(FILE* out));
 
   static const int kNoLineNumberInfo = 0;
   static const int kNoColumnInfo = 0;
   static const int kNoScriptIdInfo = 0;
 };
 
 
 /**
  * Representation of a JavaScript stack trace. The information collected is a
  * snapshot of the execution stack and the information remains valid after
@@ skipping 37 matching lines @@
    * Grab a snapshot of the current JavaScript execution stack.
    *
    * \param frame_limit The maximum number of stack frames we want to capture.
    * \param options Enumerates the set of things we will capture for each
    *   StackFrame.
    */
   static Local<StackTrace> CurrentStackTrace(
       Isolate* isolate,
       int frame_limit,
       StackTraceOptions options = kOverview);
-  // Will be deprecated soon.
-  static Local<StackTrace> CurrentStackTrace(
-      int frame_limit,
-      StackTraceOptions options = kOverview);
+  V8_DEPRECATED("Will be removed",
+                static Local<StackTrace> CurrentStackTrace(
+                    int frame_limit, StackTraceOptions options = kOverview));
 };
 
 
 /**
  * A single JavaScript stack frame.
  */
 class V8_EXPORT StackFrame {
  public:
   /**
    * Returns the number, 1-based, of the line for the associate function call.
@@ skipping 311 matching lines @@
 
 
 /**
  * A primitive boolean value (ECMA-262, 4.3.14).  Either the true
  * or false value.
  */
 class V8_EXPORT Boolean : public Primitive {
  public:
   bool Value() const;
   V8_INLINE static Handle<Boolean> New(Isolate* isolate, bool value);
-  // Will be deprecated soon.
-  V8_INLINE static Handle<Boolean> New(bool value);
+  V8_DEPRECATED("Will be removed",
+                V8_INLINE static Handle<Boolean> New(bool value));
 };
 
 
 /**
  * A JavaScript string value (ECMA-262, 4.3.17).
  */
 class V8_EXPORT String : public Primitive {
  public:
   enum Encoding {
     UNKNOWN_ENCODING = 0x1,
@@ skipping 249 matching lines @@
   /**
    * Creates a new external string using the data defined in the given
    * 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
    * this function should not otherwise delete or modify the resource. Neither
    * should the underlying buffer be deallocated or modified except through the
    * destructor of the external string resource.
    */
   static Local<String> NewExternal(Isolate* isolate,
                                    ExternalStringResource* resource);
-  // Will be deprecated soon.
-  static Local<String> NewExternal(ExternalStringResource* resource);
+  V8_DEPRECATED("Will be removed", static Local<String> NewExternal(
+                                        ExternalStringResource* resource));
 
   /**
    * Associate an external string resource with this string by transforming it
    * in place so that existing references to this string in the JavaScript heap
    * will use the external string resource. The external string resource's
    * character contents need to be equivalent to this 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
    * information on the lifetime of the resource.
    */
   bool MakeExternal(ExternalStringResource* resource);
 
   /**
    * Creates a new external string using the ASCII data defined in the given
    * 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
    * this function should not otherwise delete or modify the resource. Neither
    * should the underlying buffer be deallocated or modified except through the
    * destructor of the external string resource.
    */
   static Local<String> NewExternal(Isolate* isolate,
                                    ExternalAsciiStringResource* resource);
-  // Will be deprecated soon.
-  static Local<String> NewExternal(ExternalAsciiStringResource* resource);
+  V8_DEPRECATED("Will be removed", static Local<String> NewExternal(
+                                        ExternalAsciiStringResource* resource));
 
   /**
    * Associate an external string resource with this string by transforming it
    * in place so that existing references to this string in the JavaScript heap
    * will use the external string resource. The external string resource's
    * character contents need to be equivalent to this 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
    * information on the lifetime of the resource.
    */
@@ skipping 537 matching lines @@
    * 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(Isolate* isolate, int length = 0);
-  // Will be deprecated soon.
-  static Local<Array> New(int length = 0);
+  V8_DEPRECATED("Will be removed", static Local<Array> New(int length = 0));
 
   V8_INLINE static Array* Cast(Value* obj);
  private:
   Array();
   static void CheckCast(Value* obj);
 };
 
 
 template<typename T>
 class ReturnValue {
@@ skipping 243 matching lines @@
    */
   size_t ByteLength() const;
 
   /**
    * Create a new ArrayBuffer. Allocate |byte_length| bytes.
    * Allocated memory will be owned by a created ArrayBuffer and
    * will be deallocated when it is garbage-collected,
    * unless the object is externalized.
    */
   static Local<ArrayBuffer> New(Isolate* isolate, size_t byte_length);
-  // Will be deprecated soon.
-  static Local<ArrayBuffer> New(size_t byte_length);
+  V8_DEPRECATED("Will be removed",
+                static Local<ArrayBuffer> New(size_t byte_length));
 
   /**
    * Create a new ArrayBuffer over an existing memory block.
    * The created array buffer is immediately in externalized state.
    * The memory block will not be reclaimed when a created ArrayBuffer
    * is garbage-collected.
    */
   static Local<ArrayBuffer> New(Isolate* isolate, void* data,
                                 size_t byte_length);
-  // Will be deprecated soon.
-  static Local<ArrayBuffer> New(void* data, size_t byte_length);
+  V8_DEPRECATED("Will be removed",
+                static Local<ArrayBuffer> New(void* data, size_t byte_length));
 
   /**
    * Returns true if ArrayBuffer is extrenalized, that is, does not
    * own its memory block.
    */
   bool IsExternal() const;
 
   /**
    * Neuters this ArrayBuffer and all its views (typed arrays).
    * Neutering sets the byte length of the buffer and all typed arrays to zero,
@@ skipping 240 matching lines @@
   static void CheckCast(Value* obj);
 };
 
 
 /**
  * An instance of the built-in Date constructor (ECMA-262, 15.9).
  */
 class V8_EXPORT Date : public Object {
  public:
   static Local<Value> New(Isolate* isolate, double time);
-  // Will be deprecated soon.
-  static Local<Value> New(double time);
+  V8_DEPRECATED("Will be removed", static Local<Value> New(double time));
 
   V8_DEPRECATED(
       "Use ValueOf instead",
       double NumberValue() const) { return ValueOf(); }
 
   /**
    * A specialization of Value::NumberValue that is more efficient
    * because we know the structure of this object.
    */
   double ValueOf() const;
 
   V8_INLINE static Date* Cast(v8::Value* obj);
 
   /**
    * Notification that the embedder has changed the time zone,
    * daylight savings time, or other date / time configuration
    * parameters.  V8 keeps a cache of various values used for
    * date / time computation.  This notification will reset
    * those cached values for the current context so that date /
    * time configuration changes would be reflected in the Date
    * object.
    *
    * This API should not be called more than needed as it will
    * negatively impact the performance of date operations.
    */
   static void DateTimeConfigurationChangeNotification(Isolate* isolate);
-  // Will be deprecated soon.
-  static void DateTimeConfigurationChangeNotification();
+  V8_DEPRECATED("Will be removed",
+                static void DateTimeConfigurationChangeNotification());
 
  private:
   static void CheckCast(v8::Value* obj);
 };
 
 
 /**
  * A Number object (ECMA-262, 4.3.21).
  */
 class V8_EXPORT NumberObject : public Object {
  public:
   static Local<Value> New(Isolate* isolate, double value);
-  // Will be deprecated soon.
-  static Local<Value> New(double value);
+  V8_DEPRECATED("Will be removed", static Local<Value> New(double value));
 
   V8_DEPRECATED(
       "Use ValueOf instead",
       double NumberValue() const) { return ValueOf(); }
 
   /**
    * Returns the Number held by the object.
    */
   double ValueOf() const;
 
@@ skipping 141 matching lines @@
 
 /**
  * The superclass of object and function templates.
  */
 class V8_EXPORT 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(Isolate* isolate, const char* name, Handle<Data> value);
-  // Will be deprecated soon.
-  V8_INLINE void Set(const char* name, Handle<Data> value);
+  V8_DEPRECATED("Will be removed",
+                V8_INLINE void Set(const char* name, Handle<Data> value));
 
   void SetAccessorProperty(
      Local<String> name,
      Local<FunctionTemplate> getter = Local<FunctionTemplate>(),
      Local<FunctionTemplate> setter = Local<FunctionTemplate>(),
      PropertyAttribute attribute = None,
      AccessControl settings = DEFAULT);
 
   /**
    * Whenever the property with the given name is accessed on objects
@@ skipping 515 matching lines @@
  * A Signature specifies which receivers and arguments are valid
  * parameters to a function.
  */
 class V8_EXPORT Signature : public Data {
  public:
   static Local<Signature> New(Isolate* isolate,
                               Handle<FunctionTemplate> receiver =
                                   Handle<FunctionTemplate>(),
                               int argc = 0,
                               Handle<FunctionTemplate> argv[] = 0);
-  // Will be deprecated soon.
-  static Local<Signature> New(Handle<FunctionTemplate> receiver =
-                                  Handle<FunctionTemplate>(),
-                              int argc = 0,
-                              Handle<FunctionTemplate> argv[] = 0);
+  V8_DEPRECATED("Will be removed",
+                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 {
  public:
   static Local<AccessorSignature> New(Isolate* isolate,
                                       Handle<FunctionTemplate> receiver =
                                           Handle<FunctionTemplate>());
-  // Will be deprecated soon.
-  static Local<AccessorSignature> New(Handle<FunctionTemplate> receiver =
-                                          Handle<FunctionTemplate>());
+  V8_DEPRECATED("Will be removed", static Local<AccessorSignature> New(
+                                       Handle<FunctionTemplate> receiver =
+                                           Handle<FunctionTemplate>()));
 
  private:
   AccessorSignature();
 };
 
 
 class V8_EXPORT DeclaredAccessorDescriptor : public Data {
  private:
   DeclaredAccessorDescriptor();
 };
@@ skipping 86 matching lines @@
   // 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> GetNativeFunctionTemplate(
       v8::Isolate* isolate, v8::Handle<v8::String> name) {
+#if defined(V8_DEPRECATION_WARNINGS)
+    return v8::Handle<v8::FunctionTemplate>();
+#else
     return GetNativeFunction(name);
+#endif
   }
-  // Will be deprecated soon.
-  virtual v8::Handle<v8::FunctionTemplate>
-      GetNativeFunction(v8::Handle<v8::String> name) {
+
+  V8_DEPRECATED("Will be removed",
+                virtual v8::Handle<v8::FunctionTemplate> GetNativeFunction(
+                    v8::Handle<v8::String> name)) {
     return v8::Handle<v8::FunctionTemplate>();
   }
 
   const char* name() const { return name_; }
   size_t source_length() const { return source_length_; }
   const String::ExternalAsciiStringResource* source() const {
     return &source_; }
   int dependency_count() { return dep_count_; }
   const char** dependencies() { return deps_; }
   void set_auto_enable(bool value) { auto_enable_ = value; }
@@ skipping 27 matching lines @@
 };
 
 
 // --- Statics ---
 
 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);
 
-// Will be removed soon.
-Handle<Primitive> V8_EXPORT Undefined();
-Handle<Primitive> V8_EXPORT Null();
-Handle<Boolean> V8_EXPORT True();
-Handle<Boolean> V8_EXPORT False();
+V8_DEPRECATED("Will be removed", Handle<Primitive> V8_EXPORT Undefined());
+V8_DEPRECATED("Will be removed", Handle<Primitive> V8_EXPORT Null());
+V8_DEPRECATED("Will be removed", Handle<Boolean> V8_EXPORT True());
+V8_DEPRECATED("Will be removed", Handle<Boolean> V8_EXPORT False());
 
 
 /**
  * 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.
@@ skipping 2791 matching lines @@
  */
 
 
 }  // namespace v8
 
 
 #undef TYPE_CHECK
 
 
 #endif  // V8_H_