Refactor WindowProxy into Local and Remote subclasses.

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 17 matching lines @@
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #ifndef WindowProxy_h
 #define WindowProxy_h
 
 #include "bindings/core/v8/DOMWrapperWorld.h"
 #include "bindings/core/v8/ScopedPersistent.h"
 #include "bindings/core/v8/ScriptState.h"
 #include "platform/heap/Handle.h"
-#include "platform/weborigin/SecurityOrigin.h"
-#include "wtf/HashMap.h"
-#include "wtf/PassRefPtr.h"
 #include "wtf/RefPtr.h"
-#include "wtf/text/AtomicString.h"
 #include <v8.h>
 
 namespace blink {
 
 class Frame;
-class HTMLDocument;
-class SecurityOrigin;
+class ScriptController;
 
 // WindowProxy represents all the per-global object state for a Frame that
 // persist between navigations.
-class WindowProxy final : public GarbageCollectedFinalized<WindowProxy> {
+class WindowProxy : public GarbageCollectedFinalized<WindowProxy> {
  public:
-  static WindowProxy* create(v8::Isolate*, Frame*, DOMWrapperWorld&);
+  virtual ~WindowProxy();
 
-  ~WindowProxy();
   DECLARE_TRACE();
 
   v8::Local<v8::Context> contextIfInitialized() const {
     return m_scriptState ? m_scriptState->context() : v8::Local<v8::Context>();
   }
-  ScriptState* getScriptState() const { return m_scriptState.get(); }
-
-  // Update document object of the frame.
-  void updateDocument();
-
-  void namedItemAdded(HTMLDocument*, const AtomicString&);
-  void namedItemRemoved(HTMLDocument*, const AtomicString&);
-
-  // Update the security origin of a document
-  // (e.g., after setting docoument.domain).
-  void updateSecurityOrigin(SecurityOrigin*);
-
   void initializeIfNeeded();
 
+  void clearForClose();
   void clearForNavigation();
-  void clearForClose();
 
   v8::Local<v8::Object> globalIfNotDetached();
   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; }
 
- private:
+ 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.
   enum class Lifecycle {
     ContextUninitialized,
     ContextInitialized,
     ContextDetached,
   };
 
-  WindowProxy(Frame*, PassRefPtr<DOMWrapperWorld>, v8::Isolate*);
-  void initialize();
+  WindowProxy(Frame&, v8::Isolate*, RefPtr<DOMWrapperWorld>);

[Yuki, 2017/01/11 10:09:24]

nit: Could you put v8::Isolate* first as it's our convention?

[dcheng, 2017/01/11 10:35:29]

Done, here and elsewhere.

+
+  virtual void initialize() = 0;
 
   enum GlobalDetachmentBehavior { DoNotDetachGlobal, DetachGlobal };
-  void disposeContext(GlobalDetachmentBehavior);
-
-  void setSecurityToken(SecurityOrigin*);
-
-  // The JavaScript wrapper for the document object is cached on the global
-  // object for fast access. UpdateDocumentProperty sets the wrapper
-  // for the current document on the global object.
-  void updateDocumentProperty();
-
-  // Updates Activity Logger for the current context.
-  void updateActivityLogger();
-
-  // Creates a new v8::Context with the window wrapper object as the global
-  // object (aka the inner global).  Note that the window wrapper and its
-  // prototype chain do not get fully initialized yet, e.g. the window
-  // wrapper is not yet associated with the native DOMWindow object.
-  void createContext();
+  virtual void disposeContext(GlobalDetachmentBehavior);
 
   // Associates the window wrapper and its prototype chain with the native
   // DOMWindow object.  Also does some more Window-specific initialization.
   void setupWindowPrototypeChain();
 
-  Member<Frame> m_frame;
-  v8::Isolate* m_isolate;
+  Frame* frame() const { return m_frame.get(); }
+  v8::Isolate* isolate() const { return m_isolate; }
+  ScriptState* getScriptState() const { return m_scriptState.get(); }
+
+ private:
+  const Member<Frame> m_frame;
+  v8::Isolate* const m_isolate;
+
+ protected:

[Yuki, 2017/01/11 10:09:24]

Could you unify two protected: sections into one?

[dcheng, 2017/01/11 10:35:29]

This is a bit messy right now. However, the reason it's split into multiple
sections is to keep destruction order the same. Changing it /probably/ won't
break anything, but it's not certain. Thus, I want to do the cleanups in
followups.

In the future cleanups, all these variables are going to move into the private
section, with one exception:
- m_scriptState will be LocalWindowProxy only. Thus, I don't add a protected
getter for it since I'll have to change it back in the followup CL.
- m_world will become private once we don't need to expose world() as a getter,
by doing some cleanup in WindowProxyManager.
- m_globalProxy will stay protected and move into the above section.
- m_lifecycle will become private, and have a getter. There will be a special
way to mark this as initialized so we don't need to directly set it in the
subclasses.

+  // TODO(dcheng): Move this to LocalWindowProxy once RemoteWindowProxy uses
+  // remote contexts.
   RefPtr<ScriptState> m_scriptState;
-  RefPtr<DOMWrapperWorld> m_world;
+  // 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