Remove JITCodeEvent::CODE_REMOVED

include/v8.h

 // Copyright 2012 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 /** \mainpage V8 API Reference Guide
  *
  * V8 is Google's open source JavaScript engine.
  *
  * This set of documents provides reference material generated from the
  * V8 header file, include/v8.h.
@@ skipping 4510 matching lines @@
  * \param return_addr_location points to a location on stack where the machine
  *    return address resides. This can be used to identify the caller of
  *    \p function, and/or modified to divert execution when \p function exits.
  *
  * \note the entry hook must not cause garbage collection.
  */
 typedef void (*FunctionEntryHook)(uintptr_t function,
                                   uintptr_t return_addr_location);
 
 /**
- * A JIT code event is issued each time code is added, moved or removed.
- *
- * \note removal events are not currently issued.
+ * A JIT code event is issued each time code is added or moved.
  */
 struct JitCodeEvent {
   enum EventType {
     CODE_ADDED,
     CODE_MOVED,
-    CODE_REMOVED,
     CODE_ADD_LINE_POS_INFO,
     CODE_START_LINE_INFO_RECORDING,
     CODE_END_LINE_INFO_RECORDING
   };
   // Definition of the code position type. The "POSITION" type means the place
   // in the source code which are of interest when making stack traces to
   // pin-point the source location of a stack frame as close as possible.
   // The "STATEMENT_POSITION" means the place at the beginning of each
   // statement, and is used to indicate possible break locations.
   enum PositionType { POSITION, STATEMENT_POSITION };
@@ skipping 101 matching lines @@
      * The optional entry_hook allows the host application to provide the
      * address of a function that's invoked on entry to every V8-generated
      * function.  Note that entry_hook is invoked at the very start of each
      * generated function. Furthermore, if an  entry_hook is given, V8 will
      * always run without a context snapshot.
      */
     FunctionEntryHook entry_hook;
 
     /**
      * Allows the host application to provide the address of a function that is
-     * notified each time code is added, moved or removed.
+     * notified each time code is added or moved.
      */
     JitCodeEventHandler code_event_handler;
 
     /**
      * ResourceConstraints to use for the new Isolate.
      */
     ResourceConstraints constraints;
 
     /**
      * Explicitly specify a startup snapshot blob. The embedder owns the blob.
@@ skipping 487 matching lines @@
    * of context disposals - including this one - since the last time
    * V8 had a chance to clean up.
    *
    * The optional parameter |dependant_context| specifies whether the disposed
    * context was depending on state from other contexts or not.
    */
   int ContextDisposedNotification(bool dependant_context = true);
 
   /**
    * Allows the host application to provide the address of a function that is
-   * notified each time code is added, moved or removed.
+   * notified each time code is added or moved.
    *
    * \param options options for the JIT code event handler.
    * \param event_handler the JIT code event handler, which will be invoked
-   *     each time code is added, moved or removed.
+   *     each time code is added or moved.
    * \note \p event_handler won't get notified of existent code.
    * \note since code removal notifications are not currently issued, the
    *     \p event_handler may get notifications of code that overlaps earlier
    *     code notifications. This happens when code areas are reused, and the
    *     earlier overlapping code areas should therefore be discarded.
    * \note the events passed to \p event_handler and the strings they point to
    *     are not guaranteed to live past each call. The \p event_handler must
    *     copy strings and other parameters it needs to keep around.
    * \note the set of events declared in JitCodeEvent::EventType is expected to
    *     grow over time, and the JitCodeEvent structure is expected to accrue
@@ skipping 2356 matching lines @@
  */
 
 
 }  // namespace v8
 
 
 #undef TYPE_CHECK
 
 
 #endif  // V8_H_