Rename ScriptWrappable::newLocalWrapper to ScriptWrappable::mainWorldWrapper

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

 /*
  * Copyright (C) 2010 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 82 matching lines @@
 
     // Associates this instance with the given |wrapper| if this instance is not
     // yet associated with any wrapper.  Returns true if the given wrapper is
     // associated with this instance, or false if this instance is already
     // associated with a wrapper.  In the latter case, |wrapper| will be updated
     // to the existing wrapper.
     bool setWrapper(v8::Isolate* isolate, const WrapperTypeInfo* wrapperTypeInfo, v8::Local<v8::Object>& wrapper) WARN_UNUSED_RETURN
     {
         ASSERT(!wrapper.IsEmpty());
         if (UNLIKELY(containsWrapper())) {
-            wrapper = newLocalWrapper(isolate);
+            wrapper = mainWorldWrapper(isolate);
             return false;
         }
-        m_wrapper.Reset(isolate, wrapper);
-        wrapperTypeInfo->configureWrapper(&m_wrapper);
-        m_wrapper.SetWeak();
+        m_mainWorldWrapper.Reset(isolate, wrapper);
+        wrapperTypeInfo->configureWrapper(&m_mainWorldWrapper);
+        m_mainWorldWrapper.SetWeak();
         ASSERT(containsWrapper());
         return true;
     }
 
-    v8::Local<v8::Object> newLocalWrapper(v8::Isolate* isolate) const
-    {
-        return v8::Local<v8::Object>::New(isolate, m_wrapper);
-    }
-
     bool isEqualTo(const v8::Local<v8::Object>& other) const
     {
-        return m_wrapper == other;
+        return m_mainWorldWrapper == other;
     }
 
     // Provides a way to convert Node* to ScriptWrappable* without including
     // "core/dom/Node.h".
     //
     // Example:
     //   void foo(const void*) { ... }       // [1]
     //   void foo(ScriptWrappable*) { ... }  // [2]
     //   class Node;
     //   Node* node;
     //   foo(node);  // This calls [1] because there is no definition of Node
     //               // and compilers do not know that Node is a subclass of
     //               // ScriptWrappable.
     //   foo(ScriptWrappable::fromNode(node));  // This calls [2] as expected.
     //
     // The definition of fromNode is placed in Node.h because we'd like to
     // inline calls to fromNode as much as possible.
     static ScriptWrappable* fromNode(Node*);
 
     bool setReturnValue(v8::ReturnValue<v8::Value> returnValue)
     {
-        returnValue.Set(m_wrapper);
+        returnValue.Set(m_mainWorldWrapper);
         return containsWrapper();
     }
 
     void setReference(const v8::Persistent<v8::Object>& parent, v8::Isolate* isolate)
     {
-        isolate->SetReference(parent, m_wrapper);
+        isolate->SetReference(parent, m_mainWorldWrapper);
     }
 
-    bool containsWrapper() const { return !m_wrapper.IsEmpty(); }
+    bool containsWrapper() const { return !m_mainWorldWrapper.IsEmpty(); }
 
     /**
      *  Mark wrapper of this ScriptWrappable as alive in V8. Only marks
      *  wrapper in the main world. To mark wrappers in all worlds call
      *  ScriptWrappableVisitor::markWrapper(ScriptWrappable*, v8::Isolate*)
      */
     void markWrapper(v8::Isolate*) const;
 
     DECLARE_VIRTUAL_TRACE_WRAPPERS() {};
 
     // With Oilpan we don't need a ScriptWrappable destructor.
     //
     // 'RELEASE_ASSERT_WITH_SECURITY_IMPLICATION(!containsWrapper())' is not needed
     // because Oilpan is not using reference counting at all. If containsWrapper() is true,
     // it means that ScriptWrappable still has a wrapper. In this case, the destructor
     // must not be called since the wrapper has a persistent handle back to this ScriptWrappable object.
     // Assuming that Oilpan's GC is correct (If we cannot assume this, a lot of more things are
     // already broken), we must not hit the RELEASE_ASSERT.
 
 private:
-    v8::Persistent<v8::Object> m_wrapper;
+    friend class DOMDataStore;

[Yuki, 2016/05/31 04:43:11]

Maybe, better to comment why these classes are friend.

[haraken, 2016/05/31 04:44:33]

Done.

+    friend class V8HiddenValue;
+    friend class V8PrivateProperty;
+    friend class WebGLRenderingContextBase;
+
+    v8::Local<v8::Object> mainWorldWrapper(v8::Isolate* isolate) const
+    {
+        return v8::Local<v8::Object>::New(isolate, m_mainWorldWrapper);
+    }
+
+    v8::Persistent<v8::Object> m_mainWorldWrapper;
 };
 
 // Defines 'wrapperTypeInfo' virtual method which returns the WrapperTypeInfo of
 // the instance. Also declares a static member of type WrapperTypeInfo, of which
 // the definition is given by the IDL code generator.
 //
 // All the derived classes of ScriptWrappable, regardless of directly or
 // indirectly, must write this macro in the class definition as long as the
 // class has a corresponding .idl file.
 #define DEFINE_WRAPPERTYPEINFO() \
@@ skipping 17 matching lines @@
 // in X's cpp code, and instantiate X, i.e. "template class X;".
 #define DECLARE_WRAPPERTYPEINFO() \
 public: \
     const WrapperTypeInfo* wrapperTypeInfo() const override; \
 private: \
     typedef void end_of_define_wrappertypeinfo_not_reached_t
 
 } // namespace blink
 
 #endif // ScriptWrappable_h