v8binding: Initializes WindowProxy iff it's uninitialized.

third_party/WebKit/Source/bindings/core/v8/WindowProxy.h

 /*
  * Copyright (C) 2009 Google Inc. 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
@@ skipping 24 matching lines @@
 #include "bindings/core/v8/ScopedPersistent.h"
 #include "core/CoreExport.h"
 #include "platform/heap/Handle.h"
 #include "v8/include/v8.h"
 #include "wtf/RefPtr.h"
 
 namespace blink {
 
 class DOMWindow;
 class Frame;
-class ScriptController;
 
 // WindowProxy implements the split window model of a window for a frame. In the
 // HTML standard, the split window model is composed of the Window interface
 // (the inner global object) and the WindowProxy interface (the outer global
 // proxy).
 //
 // The Window interface is backed by the Blink DOMWindow C++ implementation.
 // In contrast, the WindowProxy interface does not have a corresponding
 // C++ implementation in Blink: the WindowProxy class defined here only manages
 // context initialization and detach. Instead, the behavior of the WindowProxy
@@ skipping 100 matching lines @@
   v8::Local<v8::Object> releaseGlobal();
   void setGlobal(v8::Local<v8::Object>);
 
   // TODO(dcheng): Temporarily exposed to avoid include cycles. Remove the need
   // for this and remove this getter.
   DOMWrapperWorld& world() { return *m_world; }
 
   virtual bool isLocal() const { return false; }
 
  protected:
-  // TODO(dcheng): Remove this friend declaration once LocalWindowProxyManager
-  // and ScriptController are merged.
-  friend class ScriptController;
-
-  // A valid transition is from ContextUninitialized to ContextInitialized,
-  // and then ContextDetached. Other transitions are forbidden.
+  // Lifecycle represents the following four states.
+  //
+  // * ContextUninitialized
+  // We lazily initialize WindowProxies for performance reasons, and this state
+  // is "to be initialized on demand". WindowProxy basically behaves the same as
+  // |ContextInitialized| from a point of view of call sites.
+  // - Possible next states: ContextInitialized
+  // It's possible to detach the context from a frame or navigate to a new page
+  // without initializing the WindowProxy, however, there is no transition to
+  // |ContextDetachedFromFrame| or |GlobalObjectDetached| because
+  // |disposeContext| does not change the state if the state is
+  // |ContextUninitialized|. In either case of a) the browsing context is
+  // detached from a frame or b) the page is navigated away, there must be no
+  // way for author script to access to the context of |ContextUninitialized|

[haraken, 2017/03/28 11:12:42]

access the context

[Yuki, 2017/03/28 12:22:16]

Done.

+  // because |ContextUninitialized| means that author script has never accessed
+  // to the context, hence there must exist no reference to the context.

[haraken, 2017/03/28 11:12:42]

accessed the context

[Yuki, 2017/03/28 12:22:16]

Done.

+  //
+  // * ContextInitialized
+  // The context is initialized and yet attached to a frame.

[haraken, 2017/03/28 11:12:42]

yet => still

[Yuki, 2017/03/28 12:22:16]

Done.

+  // - Possible next states: ContextDetachedFromFrame, GlobalObjectDetached
+  //
+  // * ContextDetachedFromFrame
+  // The context is initialized, once attached to a frame and now detached. Note
+  // that the context is still alive and author script may have references to
+  // the context and hence author script may run in the context.
+  // The spec does not support some of web features such as setTimeout, etc. on
+  // a detached window. Blink does not support more things than the spec,

[haraken, 2017/03/28 11:12:42]

// Blink supports less things than the spec.

[Yuki, 2017/03/28 12:22:16]

Done.

+  // though. V8PerContextData is cut off from the context.
+  // - Possible next states: n/a

[haraken, 2017/03/28 11:12:42]

Isn't it possible to transit from ContextDetachedFromFrame to
GlobalObjectDetached?

n/a => GlobalObjectDetached or destructor ?

[Yuki, 2017/03/28 12:22:16]

IIUC, no way.  GlobalObjectDetached means that it's navigating, but it's not
possible to navigate without attached to a frame.
Hmm, I personally don't think that "destructor" is a state.  Lifecycle doesn't
have such value.  "n/a", "nothing" or "no state"?

+  //
+  // * GlobalObjectDetached
+  // The context is initialized, attached to a frame, and now navigated away.
+  // The global object (inner global) is detached from the global proxy (outer
+  // global), but the (detached) global object and context are still alive, and
+  // author script may have reference to the context.

[haraken, 2017/03/28 11:12:42]

references

[Yuki, 2017/03/28 12:22:16]

Done.

+  // The spec does not support some of web features as same as
+  // |ContextDetachedFromFrame|. Blink does not support this state well samely.

[haraken, 2017/03/28 11:12:42]

// The spec does not support full web features in this state. Blink supports
less things than the spec.

[Yuki, 2017/03/28 12:22:16]

Done.

+  // - Possible next states: ContextUninitialized

[haraken, 2017/03/28 11:12:42]

ContextUninitialized or destructor ?

[Yuki, 2017/03/28 12:22:16]

Ditto.

+  // This state is in the middle of navigation, so the next state is
+  // |ContextUninitialized| for a new window/context/document of a new page.

[haraken, 2017/03/28 11:12:42]

This comment looks a bit confusing. It's possible that the WindowProxy gets
destructed without becoming ContextUninitialized, right?

[Yuki, 2017/03/28 12:22:16]

Oops, I was wrong on this point.  GlobalObjectDetached transitions directly to
ContextInitialized without being ContextUninitialized.

This is *Possible* next states, so the transition is not mandatory.  This is
true for all other states and transitions.  They are optional.

Anyway, I rewrote this part.

   enum class Lifecycle {
+    // v8::Context is not yet initialized.
     ContextUninitialized,
+    // v8::Context is initialized.
     ContextInitialized,
-    ContextDetached,
+    // A context is detached from a frame.
+    ContextDetachedFromFrame,
+    // The global object (inner global) is detached from the global proxy.
+    GlobalObjectDetached,
   };
 
   WindowProxy(v8::Isolate*, Frame&, RefPtr<DOMWrapperWorld>);
 
   virtual void initialize() = 0;
 
   enum GlobalDetachmentBehavior { DoNotDetachGlobal, DetachGlobal };
   virtual void disposeContext(GlobalDetachmentBehavior) = 0;
 
   WARN_UNUSED_RESULT v8::Local<v8::Object> associateWithWrapper(
@@ skipping 19 matching lines @@
  protected:
   // TODO(dcheng): Consider making these private and using getters.
   const RefPtr<DOMWrapperWorld> m_world;
   ScopedPersistent<v8::Object> m_globalProxy;
   Lifecycle m_lifecycle;
 };
 
 }  // namespace blink
 
 #endif  // WindowProxy_h