Update V8BindingDesign.md per jochen's comment

third_party/WebKit/Source/bindings/core/v8/V8BindingDesign.md

 # Design of V8 bindings
 
 This document explains key concepts in the V8 binding architecture
 except the lifetime management of DOM wrappers.
 See [V8GCController.md](V8GCController.md) to learn the lifetime management.
 
 [TOC]
 
 ## Isolate
 
-An isolate is a concept of a thread in V8.
-Isolates and threads are in 1:1 relationship.
+An isolate is a concept of an instance in V8.
+In Blink, isolates and threads are in 1:1 relationship.
 One isolate is associated with the main thread.
 One isolate is associated with one worker thread.
+An exception is a compositor worker where one isolate is shared by multiple
+compositor workers.
 
 ## Context
 
 A context is a concept of a global variable scope in V8.
 Roughly speaking, one window object corresponds to one context.
 For example, `<iframe>` has a window object different from a window object
 of its parent frame. So the context of the `<iframe>` is different from
 the context of the parent frame. Since these contexts create their own
 global variable scopes, global variables and prototype chains of the `<iframe>`
 are isolated from the ones of the parent frame.
@@ skipping 74 matching lines @@
 
 There is a second stack that operates on a much coarser granularity.
 This stack is managed by V8 binding (not by V8).
 When V8 binding invokes JavaScript, V8 binding enters a context
 and pushes the context onto the stack.
 The JavaScript starts running on the context. When the JavaScript finishes
 and the control returns back to V8 binding, V8 binding pops the context
 from the stack. Given that the control between V8 binding and V8 can be nested
 (i.e., V8 binding invokes JavaScript, which calls into V8 binding,
 which invokes another JavaScript etc), these contexts form a stack.
-The pushing and popping are done by calling v8::Context::Enter() and
-v8::Context::Exit() (or v8::Context::Scope). We call the most recently entered
-context an entered context.
+The pushing and popping are done by any V8 API that takes a context argument
+or by explicitly calling v8::Context::Enter() and v8::Context::Exit().
+We call the most recently entered context an entered context.
 
 In the above example, at the point when func() is running,
 the entered context is the context of the main frame
 (not the context of `<iframe>`).
 
 The entered context is a concept to implement the
 [entry settings object](https://html.spec.whatwg.org/multipage/webappapis.html#entry-settings-object)
 of the HTML spec. The current context is a concept to implement the
 [incumbent settings object](https://html.spec.whatwg.org/multipage/webappapis.html#incumbent-settings-object)
 of the HTML spec.
 
 In summary, the entered context is a context from which the current JavaScript
 execution was started. The current context is a context of
 the JavaScript function that is currently running.
 
+There is another special context called a debugger context.
+If a debugger is active, the debugger context may be inserted to
+the context stack.
+
 ## World
 
 A world is a concept to sandbox DOM wrappers among content scripts of
 Chrome extensions. There are three kinds of worlds: a main world,
 an isolated world and a worker world.
 A main world is a world where a normal JavaScript downloaded from the web
 is executed.
 An isolated world is a world where a content script of a Chrome extension.
 An isolate of the main thread has 1 main world and N isolated worlds.
 An isolate of a worker thread has 1 worker world and 0 isolated world.
@@ skipping 49 matching lines @@
 For example, when the main thread is operating on a frame X using a JavaScript
 in a world Y, the current context is set to a context for the pair of (X, Y).
 The current context of the main thread changes over its lifetime.
 
 On the other hand, a worker thread has 0 frame and 1 world.
 Thus a worker thread has only 1 context.
 The current context of the worker thread never changes.
 
 ## DOM wrappers and worlds
 
-For compatibility reasons (although this is not speced),
-we need to make sure that the same DOM wrapper is returned to JavaScript
-as long as the underlying C++ DOM object is alive.
+For compatibility reasons, we need to make sure that the same DOM wrapper
+is returned to JavaScript as long as the underlying C++ DOM object is alive.
 We should not return different DOM wrappers for the same C++ DOM object.
 
 Here is an example:
 
 ```html
 var div = document.createElement("div");
 div.foo = 1234;  // expando
 var p = document.createElement("p");
 p.appendChild(div);
 div = null;
@@ skipping 41 matching lines @@
 // iframe.html
 <script>
 </script>
 ```
 
 To make sure that a DOM wrapper is created in a correct context, you need to
 make sure that the current context must be set to the correct context
 whenever you call toV8(). If you're not sure what context to use,
 ask haraken@chromium.org.