API/JSClassRef.cpp

   1 /*
   2  * Copyright (C) 2006, 2007 Apple Inc.  All rights reserved.
   3  *
   4  * Redistribution and use in source and binary forms, with or without
   5  * modification, are permitted provided that the following conditions
   6  * are met:
   7  * 1. Redistributions of source code must retain the above copyright
   8  *    notice, this list of conditions and the following disclaimer.
   9  * 2. Redistributions in binary form must reproduce the above copyright
  10  *    notice, this list of conditions and the following disclaimer in the
  11  *    documentation and/or other materials provided with the distribution.
  12  *
  13  * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
  14  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  15  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  16  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE INC. OR
  17  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
  18  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
  19  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
  20  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
  21  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  22  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  23  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  24  */
  25
  26 #include "config.h"
  27 #include "JSClassRef.h"
  28
  29 #include "APICast.h"
  30 #include "Identifier.h"
  31 #include "InitializeThreading.h"
  32 #include "JSCallbackObject.h"
  33 #include "JSGlobalObject.h"
  34 #include "JSObjectRef.h"
  35 #include "ObjectPrototype.h"
  36 #include "JSCInlines.h"
  37 #include <wtf/text/StringHash.h>
  38 #include <wtf/unicode/UTF8.h>
  39
  40 using namespace std;
  41 using namespace JSC;
  42 using namespace WTF::Unicode;
  43
  44 const JSClassDefinition kJSClassDefinitionEmpty = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
  45
  46 OpaqueJSClass::OpaqueJSClass(const JSClassDefinition* definition, OpaqueJSClass* protoClass)
  47     : parentClass(definition->parentClass)
  48     , prototypeClass(0)
  49     , initialize(definition->initialize)
  50     , finalize(definition->finalize)
  51     , hasProperty(definition->hasProperty)
  52     , getProperty(definition->getProperty)
  53     , setProperty(definition->setProperty)
  54     , deleteProperty(definition->deleteProperty)
  55     , getPropertyNames(definition->getPropertyNames)
  56     , callAsFunction(definition->callAsFunction)
  57     , callAsConstructor(definition->callAsConstructor)
  58     , hasInstance(definition->hasInstance)
  59     , convertToType(definition->convertToType)
  60     , m_className(String::fromUTF8(definition->className))
  61 {
  62     initializeThreading();
  63
  64     if (const JSStaticValue* staticValue = definition->staticValues) {
  65         m_staticValues = adoptPtr(new OpaqueJSClassStaticValuesTable);
  66         while (staticValue->name) {
  67             String valueName = String::fromUTF8(staticValue->name);
  68             if (!valueName.isNull())
  69                 m_staticValues->set(valueName.impl(), std::make_unique<StaticValueEntry>(staticValue->getProperty, staticValue->setProperty, staticValue->attributes, valueName));
  70             ++staticValue;
  71         }
  72     }
  73
  74     if (const JSStaticFunction* staticFunction = definition->staticFunctions) {
  75         m_staticFunctions = adoptPtr(new OpaqueJSClassStaticFunctionsTable);
  76         while (staticFunction->name) {
  77             String functionName = String::fromUTF8(staticFunction->name);
  78             if (!functionName.isNull())
  79                 m_staticFunctions->set(functionName.impl(), std::make_unique<StaticFunctionEntry>(staticFunction->callAsFunction, staticFunction->attributes));
  80             ++staticFunction;
  81         }
  82     }
  83
  84     if (protoClass)
  85         prototypeClass = JSClassRetain(protoClass);
  86 }
  87
  88 OpaqueJSClass::~OpaqueJSClass()
  89 {
  90     // The empty string is shared across threads & is an identifier, in all other cases we should have done a deep copy in className(), below.
  91     ASSERT(!m_className.length() || !m_className.impl()->isAtomic());
  92
  93 #ifndef NDEBUG
  94     if (m_staticValues) {
  95         OpaqueJSClassStaticValuesTable::const_iterator end = m_staticValues->end();
  96         for (OpaqueJSClassStaticValuesTable::const_iterator it = m_staticValues->begin(); it != end; ++it)
  97             ASSERT(!it->key->isAtomic());
  98     }
  99
 100     if (m_staticFunctions) {
 101         OpaqueJSClassStaticFunctionsTable::const_iterator end = m_staticFunctions->end();
 102         for (OpaqueJSClassStaticFunctionsTable::const_iterator it = m_staticFunctions->begin(); it != end; ++it)
 103             ASSERT(!it->key->isAtomic());
 104     }
 105 #endif
 106
 107     if (prototypeClass)
 108         JSClassRelease(prototypeClass);
 109 }
 110
 111 PassRefPtr<OpaqueJSClass> OpaqueJSClass::createNoAutomaticPrototype(const JSClassDefinition* definition)
 112 {
 113     return adoptRef(new OpaqueJSClass(definition, 0));
 114 }
 115
 116 PassRefPtr<OpaqueJSClass> OpaqueJSClass::create(const JSClassDefinition* clientDefinition)
 117 {
 118     JSClassDefinition definition = *clientDefinition; // Avoid modifying client copy.
 119
 120     JSClassDefinition protoDefinition = kJSClassDefinitionEmpty;
 121     protoDefinition.finalize = 0;
 122     swap(definition.staticFunctions, protoDefinition.staticFunctions); // Move static functions to the prototype.
 123
 124     // We are supposed to use JSClassRetain/Release but since we know that we currently have
 125     // the only reference to this class object we cheat and use a RefPtr instead.
 126     RefPtr<OpaqueJSClass> protoClass = adoptRef(new OpaqueJSClass(&protoDefinition, 0));
 127     return adoptRef(new OpaqueJSClass(&definition, protoClass.get()));
 128 }
 129
 130 OpaqueJSClassContextData::OpaqueJSClassContextData(JSC::VM&, OpaqueJSClass* jsClass)
 131     : m_class(jsClass)
 132 {
 133     if (jsClass->m_staticValues) {
 134         staticValues = std::make_unique<OpaqueJSClassStaticValuesTable>();
 135         OpaqueJSClassStaticValuesTable::const_iterator end = jsClass->m_staticValues->end();
 136         for (OpaqueJSClassStaticValuesTable::const_iterator it = jsClass->m_staticValues->begin(); it != end; ++it) {
 137             ASSERT(!it->key->isAtomic());
 138             String valueName = it->key->isolatedCopy();
 139             staticValues->add(valueName.impl(), std::make_unique<StaticValueEntry>(it->value->getProperty, it->value->setProperty, it->value->attributes, valueName));
 140         }
 141     }
 142
 143     if (jsClass->m_staticFunctions) {
 144         staticFunctions = std::make_unique<OpaqueJSClassStaticFunctionsTable>();
 145         OpaqueJSClassStaticFunctionsTable::const_iterator end = jsClass->m_staticFunctions->end();
 146         for (OpaqueJSClassStaticFunctionsTable::const_iterator it = jsClass->m_staticFunctions->begin(); it != end; ++it) {
 147             ASSERT(!it->key->isAtomic());
 148             staticFunctions->add(it->key->isolatedCopy(), std::make_unique<StaticFunctionEntry>(it->value->callAsFunction, it->value->attributes));
 149         }
 150     }
 151 }
 152
 153 OpaqueJSClassContextData& OpaqueJSClass::contextData(ExecState* exec)
 154 {
 155     std::unique_ptr<OpaqueJSClassContextData>& contextData = exec->lexicalGlobalObject()->opaqueJSClassData().add(this, nullptr).iterator->value;
 156     if (!contextData)
 157         contextData = std::make_unique<OpaqueJSClassContextData>(exec->vm(), this);
 158     return *contextData;
 159 }
 160
 161 String OpaqueJSClass::className()
 162 {
 163     // Make a deep copy, so that the caller has no chance to put the original into AtomicStringTable.
 164     return m_className.isolatedCopy();
 165 }
 166
 167 OpaqueJSClassStaticValuesTable* OpaqueJSClass::staticValues(JSC::ExecState* exec)
 168 {
 169     return contextData(exec).staticValues.get();
 170 }
 171
 172 OpaqueJSClassStaticFunctionsTable* OpaqueJSClass::staticFunctions(JSC::ExecState* exec)
 173 {
 174     return contextData(exec).staticFunctions.get();
 175 }
 176
 177 /*!
 178 // Doc here in case we make this public. (Hopefully we won't.)
 179 @function
 180  @abstract Returns the prototype that will be used when constructing an object with a given class.
 181  @param ctx The execution context to use.
 182  @param jsClass A JSClass whose prototype you want to get.
 183  @result The JSObject prototype that was automatically generated for jsClass, or NULL if no prototype was automatically generated. This is the prototype that will be used when constructing an object using jsClass.
 184 */
 185 JSObject* OpaqueJSClass::prototype(ExecState* exec)
 186 {
 187     /* Class (C++) and prototype (JS) inheritance are parallel, so:
 188      *     (C++)      |        (JS)
 189      *   ParentClass  |   ParentClassPrototype
 190      *       ^        |          ^
 191      *       |        |          |
 192      *  DerivedClass  |  DerivedClassPrototype
 193      */
 194
 195     if (!prototypeClass)
 196         return 0;
 197
 198     OpaqueJSClassContextData& jsClassData = contextData(exec);
 199
 200     if (JSObject* prototype = jsClassData.cachedPrototype.get())
 201         return prototype;
 202
 203     // Recursive, but should be good enough for our purposes
 204     JSObject* prototype = JSCallbackObject<JSDestructibleObject>::create(exec, exec->lexicalGlobalObject(), exec->lexicalGlobalObject()->callbackObjectStructure(), prototypeClass, &jsClassData); // set jsClassData as the object's private data, so it can clear our reference on destruction
 205     if (parentClass) {
 206         if (JSObject* parentPrototype = parentClass->prototype(exec))
 207             prototype->setPrototype(exec->vm(), parentPrototype);
 208     }
 209
 210     jsClassData.cachedPrototype = Weak<JSObject>(prototype);
 211     return prototype;
 212 }