Minor typos in v8.h code documentation.

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 3571 matching lines @@
    * Neuters this ArrayBuffer and all its views (typed arrays).
    * Neutering sets the byte length of the buffer and all typed arrays to zero,
    * preventing JavaScript from ever accessing underlying backing store.
    * ArrayBuffer should have been externalized and must be neuterable.
    */
   void Neuter();
 
   /**
    * Make this ArrayBuffer external. The pointer to underlying memory block
    * and byte length are returned as |Contents| structure. After ArrayBuffer
-   * had been etxrenalized, it does no longer owns the memory block. The caller
+   * had been externalized, it does no longer own the memory block. The caller
    * should take steps to free memory when it is no longer needed.
    *
    * The memory block is guaranteed to be allocated with |Allocator::Allocate|
    * that has been set via Isolate::CreateParams.
    */
   Contents Externalize();
 
   /**
    * Get a pointer to the ArrayBuffer's underlying memory block without
    * externalizing it. If the ArrayBuffer is not externalized, this pointer
-   * will become invalid as soon as the ArrayBuffer became garbage collected.
+   * will become invalid as soon as the ArrayBuffer gets garbage collected.
    *
    * The embedder should make sure to hold a strong reference to the
    * ArrayBuffer while accessing this pointer.
    *
    * The memory block is guaranteed to be allocated with |Allocator::Allocate|.
    */
   Contents GetContents();
 
   V8_INLINE static ArrayBuffer* Cast(Value* obj);
 
@@ skipping 31 matching lines @@
    * Size of a view in bytes.
    */
   size_t ByteLength();
 
   /**
    * Copy the contents of the ArrayBufferView's buffer to an embedder defined
    * memory without additional overhead that calling ArrayBufferView::Buffer
    * might incur.
    *
    * Will write at most min(|byte_length|, ByteLength) bytes starting at
-   * ByteOffset of the underling buffer to the memory starting at |dest|.
+   * ByteOffset of the underlying buffer to the memory starting at |dest|.
    * Returns the number of bytes actually written.
    */
   size_t CopyContents(void* dest, size_t byte_length);
 
   /**
    * Returns true if ArrayBufferView's backing ArrayBuffer has already been
    * allocated.
    */
   bool HasBuffer() const;
 
@@ skipping 266 matching lines @@
 
   /**
    * Returns true if SharedArrayBuffer is externalized, that is, does not
    * own its memory block.
    */
   bool IsExternal() const;
 
   /**
    * Make this SharedArrayBuffer external. The pointer to underlying memory
    * block and byte length are returned as |Contents| structure. After
-   * SharedArrayBuffer had been etxrenalized, it does no longer owns the memory
+   * SharedArrayBuffer had been externalized, it does no longer own the memory
    * block. The caller should take steps to free memory when it is no longer
    * needed.
    *
    * The memory block is guaranteed to be allocated with |Allocator::Allocate|
    * by the allocator specified in
    * v8::Isolate::CreateParams::array_buffer_allocator.
    *
    */
   Contents Externalize();
 
@@ skipping 442 matching lines @@
 
 /**
  * A FunctionTemplate is used to create functions at runtime. There
  * can only be one function created from a FunctionTemplate in a
  * context.  The lifetime of the created function is equal to the
  * lifetime of the context.  So in case the embedder needs to create
  * temporary functions that can be collected using Scripts is
  * preferred.
  *
  * Any modification of a FunctionTemplate after first instantiation will trigger
- *a crash.
+ * a crash.
  *
  * A FunctionTemplate can have properties, these properties are added to the
  * function object when it is created.
  *
  * A FunctionTemplate has a corresponding instance template which is
  * used to create object instances when the function is used as a
  * constructor. Properties added to the instance template are added to
  * each object instance.
  *
  * A FunctionTemplate can have a prototype template. The prototype template
@@ skipping 2804 matching lines @@
 
   /**
    * Sets the embedder data with the given index, growing the data as
    * needed. Note that index 0 currently has a special meaning for Chrome's
    * debugger.
    */
   void SetEmbedderData(int index, Local<Value> value);
 
   /**
    * Gets a 2-byte-aligned native pointer from the embedder data with the given
-   * index, which must have bees set by a previous call to
+   * index, which must have been set by a previous call to
    * SetAlignedPointerInEmbedderData with the same index. Note that index 0
    * currently has a special meaning for Chrome's debugger.
    */
   V8_INLINE void* GetAlignedPointerFromEmbedderData(int index);
 
   /**
    * Sets a 2-byte-aligned native pointer in the embedder data with the given
    * index, growing the data as needed. Note that index 0 currently has a
    * special meaning for Chrome's debugger.
    */
@@ skipping 59 matching lines @@
 
 
 /**
  * Multiple threads in V8 are allowed, but only one thread at a time is allowed
  * to use any given V8 isolate, see the comments in the Isolate class. The
  * definition of 'using a V8 isolate' includes accessing handles or holding onto
  * object pointers obtained from V8 handles while in the particular V8 isolate.
  * It is up to the user of V8 to ensure, perhaps with locking, that this
  * constraint is not violated. In addition to any other synchronization
  * mechanism that may be used, the v8::Locker and v8::Unlocker classes must be
- * used to signal thead switches to V8.
+ * used to signal thread switches to V8.
  *
  * v8::Locker is a scoped lock object. While it's active, i.e. between its
  * construction and destruction, the current thread is allowed to use the locked
  * isolate. V8 guarantees that an isolate can be locked by at most one thread at
  * any time. In other words, the scope of a v8::Locker is a critical section.
  *
  * Sample usage:
 * \code
  * ...
  * {
@@ skipping 1593 matching lines @@
  */
 
 
 }  // namespace v8
 
 
 #undef TYPE_CHECK
 
 
 #endif  // INCLUDE_V8_H_