Only generate isObservable() when IDL specifies GenerateIsReachable
authordbates@webkit.org <dbates@webkit.org@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Thu, 21 Nov 2013 23:19:25 +0000 (23:19 +0000)
committerdbates@webkit.org <dbates@webkit.org@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Thu, 21 Nov 2013 23:19:25 +0000 (23:19 +0000)
https://bugs.webkit.org/show_bug.cgi?id=124729

Reviewed by Geoffrey Garen.

We should only generate the static inline function isObservable() when the IDL
specifies GenerateIsReachable. Otherwise, this function is unused.

Added a new test IDL TestGenerateIsReachable.idl and expected results to test that
we generate isObservable() when an IDL specifies GenerateIsReachable. Additionally,
rebased existing test results.

* bindings/scripts/CodeGeneratorJS.pm:
(GenerateImplementation):
* bindings/scripts/test/CPP/WebDOMTestGenerateIsReachable.cpp: Added.
* bindings/scripts/test/CPP/WebDOMTestGenerateIsReachable.h: Added.
* bindings/scripts/test/GObject/WebKitDOMTestGenerateIsReachable.cpp: Added.
* bindings/scripts/test/GObject/WebKitDOMTestGenerateIsReachable.h: Added.
* bindings/scripts/test/GObject/WebKitDOMTestGenerateIsReachablePrivate.h: Added.
* bindings/scripts/test/JS/JSTestActiveDOMObject.cpp: Removed unused function isObservable().
* bindings/scripts/test/JS/JSTestCustomNamedGetter.cpp: Ditto.
* bindings/scripts/test/JS/JSTestEventConstructor.cpp: Ditto.
* bindings/scripts/test/JS/JSTestEventTarget.cpp: Ditto.
* bindings/scripts/test/JS/JSTestException.cpp: Ditto.
* bindings/scripts/test/JS/JSTestGenerateIsReachable.cpp: Added.
* bindings/scripts/test/JS/JSTestGenerateIsReachable.h: Added.
* bindings/scripts/test/JS/JSTestInterface.cpp: Removed unused function isObservable().
* bindings/scripts/test/JS/JSTestMediaQueryListListener.cpp: Ditto.
* bindings/scripts/test/JS/JSTestNamedConstructor.cpp: Ditto.
* bindings/scripts/test/JS/JSTestObj.cpp: Ditto.
* bindings/scripts/test/JS/JSTestOverloadedConstructors.cpp: Ditto.
* bindings/scripts/test/JS/JSTestSerializedScriptValueInterface.cpp: Ditto.
* bindings/scripts/test/JS/JSTestTypedefs.cpp: Ditto.
* bindings/scripts/test/JS/JSattribute.cpp: Ditto.
* bindings/scripts/test/JS/JSreadonly.cpp: Ditto.
* bindings/scripts/test/ObjC/DOMTestGenerateIsReachable.h: Added.
* bindings/scripts/test/ObjC/DOMTestGenerateIsReachable.mm: Added.
* bindings/scripts/test/ObjC/DOMTestGenerateIsReachableInternal.h: Added.
* bindings/scripts/test/TestGenerateIsReachable.idl: Added.

git-svn-id: https://svn.webkit.org/repository/webkit/trunk@159648 268f45cc-cd09-0410-ab3c-d52691b4dbfc

27 files changed:
Source/WebCore/ChangeLog
Source/WebCore/bindings/scripts/CodeGeneratorJS.pm
Source/WebCore/bindings/scripts/test/CPP/WebDOMTestGenerateIsReachable.cpp [new file with mode: 0644]
Source/WebCore/bindings/scripts/test/CPP/WebDOMTestGenerateIsReachable.h [new file with mode: 0644]
Source/WebCore/bindings/scripts/test/GObject/WebKitDOMTestGenerateIsReachable.cpp [new file with mode: 0644]
Source/WebCore/bindings/scripts/test/GObject/WebKitDOMTestGenerateIsReachable.h [new file with mode: 0644]
Source/WebCore/bindings/scripts/test/GObject/WebKitDOMTestGenerateIsReachablePrivate.h [new file with mode: 0644]
Source/WebCore/bindings/scripts/test/JS/JSTestActiveDOMObject.cpp
Source/WebCore/bindings/scripts/test/JS/JSTestCustomNamedGetter.cpp
Source/WebCore/bindings/scripts/test/JS/JSTestEventConstructor.cpp
Source/WebCore/bindings/scripts/test/JS/JSTestEventTarget.cpp
Source/WebCore/bindings/scripts/test/JS/JSTestException.cpp
Source/WebCore/bindings/scripts/test/JS/JSTestGenerateIsReachable.cpp [new file with mode: 0644]
Source/WebCore/bindings/scripts/test/JS/JSTestGenerateIsReachable.h [new file with mode: 0644]
Source/WebCore/bindings/scripts/test/JS/JSTestInterface.cpp
Source/WebCore/bindings/scripts/test/JS/JSTestMediaQueryListListener.cpp
Source/WebCore/bindings/scripts/test/JS/JSTestNamedConstructor.cpp
Source/WebCore/bindings/scripts/test/JS/JSTestObj.cpp
Source/WebCore/bindings/scripts/test/JS/JSTestOverloadedConstructors.cpp
Source/WebCore/bindings/scripts/test/JS/JSTestSerializedScriptValueInterface.cpp
Source/WebCore/bindings/scripts/test/JS/JSTestTypedefs.cpp
Source/WebCore/bindings/scripts/test/JS/JSattribute.cpp
Source/WebCore/bindings/scripts/test/JS/JSreadonly.cpp
Source/WebCore/bindings/scripts/test/ObjC/DOMTestGenerateIsReachable.h [new file with mode: 0644]
Source/WebCore/bindings/scripts/test/ObjC/DOMTestGenerateIsReachable.mm [new file with mode: 0644]
Source/WebCore/bindings/scripts/test/ObjC/DOMTestGenerateIsReachableInternal.h [new file with mode: 0644]
Source/WebCore/bindings/scripts/test/TestGenerateIsReachable.idl [new file with mode: 0644]

index c92f720..a9d96a7 100644 (file)
@@ -1,3 +1,45 @@
+2013-11-21  Daniel Bates  <dabates@apple.com>
+
+        Only generate isObservable() when IDL specifies GenerateIsReachable
+        https://bugs.webkit.org/show_bug.cgi?id=124729
+
+        Reviewed by Geoffrey Garen.
+
+        We should only generate the static inline function isObservable() when the IDL
+        specifies GenerateIsReachable. Otherwise, this function is unused.
+
+        Added a new test IDL TestGenerateIsReachable.idl and expected results to test that
+        we generate isObservable() when an IDL specifies GenerateIsReachable. Additionally,
+        rebased existing test results.
+
+        * bindings/scripts/CodeGeneratorJS.pm:
+        (GenerateImplementation):
+        * bindings/scripts/test/CPP/WebDOMTestGenerateIsReachable.cpp: Added.
+        * bindings/scripts/test/CPP/WebDOMTestGenerateIsReachable.h: Added.
+        * bindings/scripts/test/GObject/WebKitDOMTestGenerateIsReachable.cpp: Added.
+        * bindings/scripts/test/GObject/WebKitDOMTestGenerateIsReachable.h: Added.
+        * bindings/scripts/test/GObject/WebKitDOMTestGenerateIsReachablePrivate.h: Added.
+        * bindings/scripts/test/JS/JSTestActiveDOMObject.cpp: Removed unused function isObservable().
+        * bindings/scripts/test/JS/JSTestCustomNamedGetter.cpp: Ditto.
+        * bindings/scripts/test/JS/JSTestEventConstructor.cpp: Ditto.
+        * bindings/scripts/test/JS/JSTestEventTarget.cpp: Ditto.
+        * bindings/scripts/test/JS/JSTestException.cpp: Ditto.
+        * bindings/scripts/test/JS/JSTestGenerateIsReachable.cpp: Added.
+        * bindings/scripts/test/JS/JSTestGenerateIsReachable.h: Added.
+        * bindings/scripts/test/JS/JSTestInterface.cpp: Removed unused function isObservable().
+        * bindings/scripts/test/JS/JSTestMediaQueryListListener.cpp: Ditto.
+        * bindings/scripts/test/JS/JSTestNamedConstructor.cpp: Ditto.
+        * bindings/scripts/test/JS/JSTestObj.cpp: Ditto.
+        * bindings/scripts/test/JS/JSTestOverloadedConstructors.cpp: Ditto.
+        * bindings/scripts/test/JS/JSTestSerializedScriptValueInterface.cpp: Ditto.
+        * bindings/scripts/test/JS/JSTestTypedefs.cpp: Ditto.
+        * bindings/scripts/test/JS/JSattribute.cpp: Ditto.
+        * bindings/scripts/test/JS/JSreadonly.cpp: Ditto.
+        * bindings/scripts/test/ObjC/DOMTestGenerateIsReachable.h: Added.
+        * bindings/scripts/test/ObjC/DOMTestGenerateIsReachable.mm: Added.
+        * bindings/scripts/test/ObjC/DOMTestGenerateIsReachableInternal.h: Added.
+        * bindings/scripts/test/TestGenerateIsReachable.idl: Added.
+
 2013-11-21  Beth Dakin  <bdakin@apple.com>
 
         Add a new mode to extend the tile cache beyond the page
index cd71a18..740daf0 100644 (file)
@@ -2545,17 +2545,19 @@ sub GenerateImplementation
         }
     }
 
-    if ((!$hasParent && !GetCustomIsReachable($interface))|| GetGenerateIsReachable($interface) || $codeGenerator->InheritsExtendedAttribute($interface, "ActiveDOMObject")) {
-        push(@implContent, "static inline bool isObservable(JS${interfaceName}* js${interfaceName})\n");
-        push(@implContent, "{\n");
-        push(@implContent, "    if (js${interfaceName}->hasCustomProperties())\n");
-        push(@implContent, "        return true;\n");
-        if ($eventTarget) {
-            push(@implContent, "    if (js${interfaceName}->impl().hasEventListeners())\n");
+    if ((!$hasParent && !GetCustomIsReachable($interface)) || GetGenerateIsReachable($interface) || $codeGenerator->InheritsExtendedAttribute($interface, "ActiveDOMObject")) {
+        if (GetGenerateIsReachable($interface)) {
+            push(@implContent, "static inline bool isObservable(JS${interfaceName}* js${interfaceName})\n");
+            push(@implContent, "{\n");
+            push(@implContent, "    if (js${interfaceName}->hasCustomProperties())\n");
             push(@implContent, "        return true;\n");
+            if ($eventTarget) {
+                push(@implContent, "    if (js${interfaceName}->impl().hasEventListeners())\n");
+                push(@implContent, "        return true;\n");
+            }
+            push(@implContent, "    return false;\n");
+            push(@implContent, "}\n\n");
         }
-        push(@implContent, "    return false;\n");
-        push(@implContent, "}\n\n");
 
         push(@implContent, "bool JS${interfaceName}Owner::isReachableFromOpaqueRoots(JSC::Handle<JSC::Unknown> handle, void*, SlotVisitor& visitor)\n");
         push(@implContent, "{\n");
diff --git a/Source/WebCore/bindings/scripts/test/CPP/WebDOMTestGenerateIsReachable.cpp b/Source/WebCore/bindings/scripts/test/CPP/WebDOMTestGenerateIsReachable.cpp
new file mode 100644 (file)
index 0000000..42d1252
--- /dev/null
@@ -0,0 +1,82 @@
+/*
+ * This file is part of the WebKit open source project.
+ * This file has been generated by generate-bindings.pl. DO NOT MODIFY!
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public License
+ * along with this library; see the file COPYING.LIB.  If not, write to
+ * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ * Boston, MA 02110-1301, USA.
+ */
+
+#include "config.h"
+#include "WebDOMTestGenerateIsReachable.h"
+
+#include "TestGenerateIsReachable.h"
+#include "WebExceptionHandler.h"
+#include <wtf/GetPtr.h>
+#include <wtf/RefPtr.h>
+
+struct WebDOMTestGenerateIsReachable::WebDOMTestGenerateIsReachablePrivate {
+    WebDOMTestGenerateIsReachablePrivate(WebCore::TestGenerateIsReachable* object = 0)
+        : impl(object)
+    {
+    }
+
+    RefPtr<WebCore::TestGenerateIsReachable> impl;
+};
+
+WebDOMTestGenerateIsReachable::WebDOMTestGenerateIsReachable()
+    : WebDOMObject()
+    , m_impl(0)
+{
+}
+
+WebDOMTestGenerateIsReachable::WebDOMTestGenerateIsReachable(WebCore::TestGenerateIsReachable* impl)
+    : WebDOMObject()
+    , m_impl(new WebDOMTestGenerateIsReachablePrivate(impl))
+{
+}
+
+WebDOMTestGenerateIsReachable::WebDOMTestGenerateIsReachable(const WebDOMTestGenerateIsReachable& copy)
+    : WebDOMObject()
+{
+    m_impl = copy.impl() ? new WebDOMTestGenerateIsReachablePrivate(copy.impl()) : 0;
+}
+
+WebDOMTestGenerateIsReachable& WebDOMTestGenerateIsReachable::operator=(const WebDOMTestGenerateIsReachable& copy)
+{
+    delete m_impl;
+    m_impl = copy.impl() ? new WebDOMTestGenerateIsReachablePrivate(copy.impl()) : 0;
+    return *this;
+}
+
+WebCore::TestGenerateIsReachable* WebDOMTestGenerateIsReachable::impl() const
+{
+    return m_impl ? WTF::getPtr(m_impl->impl) : 0;
+}
+
+WebDOMTestGenerateIsReachable::~WebDOMTestGenerateIsReachable()
+{
+    delete m_impl;
+    m_impl = 0;
+}
+
+WebCore::TestGenerateIsReachable* toWebCore(const WebDOMTestGenerateIsReachable& wrapper)
+{
+    return wrapper.impl();
+}
+
+WebDOMTestGenerateIsReachable toWebKit(WebCore::TestGenerateIsReachable* value)
+{
+    return WebDOMTestGenerateIsReachable(value);
+}
diff --git a/Source/WebCore/bindings/scripts/test/CPP/WebDOMTestGenerateIsReachable.h b/Source/WebCore/bindings/scripts/test/CPP/WebDOMTestGenerateIsReachable.h
new file mode 100644 (file)
index 0000000..8d4b8e5
--- /dev/null
@@ -0,0 +1,53 @@
+/*
+ * Copyright (C) Research In Motion Limited 2010. All rights reserved.
+ * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009 Apple Inc. All rights reserved.
+ * Copyright (C) 2006 Samuel Weinig <sam.weinig@gmail.com>
+ * Copyright (C) Research In Motion Limited 2010. All rights reserved.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public License
+ * along with this library; see the file COPYING.LIB.  If not, write to
+ * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ * Boston, MA 02110-1301, USA.
+ */
+
+#ifndef WebDOMTestGenerateIsReachable_h
+#define WebDOMTestGenerateIsReachable_h
+
+#include <WebDOMObject.h>
+#include <WebDOMString.h>
+
+namespace WebCore {
+class TestGenerateIsReachable;
+};
+
+
+class WebDOMTestGenerateIsReachable : public WebDOMObject {
+public:
+    WebDOMTestGenerateIsReachable();
+    explicit WebDOMTestGenerateIsReachable(WebCore::TestGenerateIsReachable*);
+    WebDOMTestGenerateIsReachable(const WebDOMTestGenerateIsReachable&);
+    WebDOMTestGenerateIsReachable& operator=(const WebDOMTestGenerateIsReachable&);
+    virtual ~WebDOMTestGenerateIsReachable();
+
+
+    WebCore::TestGenerateIsReachable* impl() const;
+
+protected:
+    struct WebDOMTestGenerateIsReachablePrivate;
+    WebDOMTestGenerateIsReachablePrivate* m_impl;
+};
+
+WebCore::TestGenerateIsReachable* toWebCore(const WebDOMTestGenerateIsReachable&);
+WebDOMTestGenerateIsReachable toWebKit(WebCore::TestGenerateIsReachable*);
+
+#endif
diff --git a/Source/WebCore/bindings/scripts/test/GObject/WebKitDOMTestGenerateIsReachable.cpp b/Source/WebCore/bindings/scripts/test/GObject/WebKitDOMTestGenerateIsReachable.cpp
new file mode 100644 (file)
index 0000000..c8587ec
--- /dev/null
@@ -0,0 +1,103 @@
+/*
+ *  This file is part of the WebKit open source project.
+ *  This file has been generated by generate-bindings.pl. DO NOT MODIFY!
+ *
+ *  This library is free software; you can redistribute it and/or
+ *  modify it under the terms of the GNU Library General Public
+ *  License as published by the Free Software Foundation; either
+ *  version 2 of the License, or (at your option) any later version.
+ *
+ *  This library is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ *  Library General Public License for more details.
+ *
+ *  You should have received a copy of the GNU Library General Public License
+ *  along with this library; see the file COPYING.LIB.  If not, write to
+ *  the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ *  Boston, MA 02110-1301, USA.
+ */
+
+#include "config.h"
+#include "WebKitDOMTestGenerateIsReachable.h"
+
+#include "CSSImportRule.h"
+#include "DOMObjectCache.h"
+#include "Document.h"
+#include "ExceptionCode.h"
+#include "JSMainThreadExecState.h"
+#include "WebKitDOMPrivate.h"
+#include "WebKitDOMTestGenerateIsReachablePrivate.h"
+#include "gobject/ConvertToUTF8String.h"
+#include <wtf/GetPtr.h>
+#include <wtf/RefPtr.h>
+
+#define WEBKIT_DOM_TEST_GENERATE_IS_REACHABLE_GET_PRIVATE(obj) G_TYPE_INSTANCE_GET_PRIVATE(obj, WEBKIT_TYPE_DOM_TEST_GENERATE_IS_REACHABLE, WebKitDOMTestGenerateIsReachablePrivate)
+
+typedef struct _WebKitDOMTestGenerateIsReachablePrivate {
+    RefPtr<WebCore::TestGenerateIsReachable> coreObject;
+} WebKitDOMTestGenerateIsReachablePrivate;
+
+namespace WebKit {
+
+WebKitDOMTestGenerateIsReachable* kit(WebCore::TestGenerateIsReachable* obj)
+{
+    if (!obj)
+        return 0;
+
+    if (gpointer ret = DOMObjectCache::get(obj))
+        return WEBKIT_DOM_TEST_GENERATE_IS_REACHABLE(ret);
+
+    return wrapTestGenerateIsReachable(obj);
+}
+
+WebCore::TestGenerateIsReachable* core(WebKitDOMTestGenerateIsReachable* request)
+{
+    return request ? static_cast<WebCore::TestGenerateIsReachable*>(WEBKIT_DOM_OBJECT(request)->coreObject) : 0;
+}
+
+WebKitDOMTestGenerateIsReachable* wrapTestGenerateIsReachable(WebCore::TestGenerateIsReachable* coreObject)
+{
+    ASSERT(coreObject);
+    return WEBKIT_DOM_TEST_GENERATE_IS_REACHABLE(g_object_new(WEBKIT_TYPE_DOM_TEST_GENERATE_IS_REACHABLE, "core-object", coreObject, NULL));
+}
+
+} // namespace WebKit
+
+G_DEFINE_TYPE(WebKitDOMTestGenerateIsReachable, webkit_dom_test_generate_is_reachable, WEBKIT_TYPE_DOM_OBJECT)
+
+static void webkit_dom_test_generate_is_reachable_finalize(GObject* object)
+{
+    WebKitDOMTestGenerateIsReachablePrivate* priv = WEBKIT_DOM_TEST_GENERATE_IS_REACHABLE_GET_PRIVATE(object);
+
+    WebKit::DOMObjectCache::forget(priv->coreObject.get());
+
+    priv->~WebKitDOMTestGenerateIsReachablePrivate();
+    G_OBJECT_CLASS(webkit_dom_test_generate_is_reachable_parent_class)->finalize(object);
+}
+
+static GObject* webkit_dom_test_generate_is_reachable_constructor(GType type, guint constructPropertiesCount, GObjectConstructParam* constructProperties)
+{
+    GObject* object = G_OBJECT_CLASS(webkit_dom_test_generate_is_reachable_parent_class)->constructor(type, constructPropertiesCount, constructProperties);
+
+    WebKitDOMTestGenerateIsReachablePrivate* priv = WEBKIT_DOM_TEST_GENERATE_IS_REACHABLE_GET_PRIVATE(object);
+    priv->coreObject = static_cast<WebCore::TestGenerateIsReachable*>(WEBKIT_DOM_OBJECT(object)->coreObject);
+    WebKit::DOMObjectCache::put(priv->coreObject.get(), object);
+
+    return object;
+}
+
+static void webkit_dom_test_generate_is_reachable_class_init(WebKitDOMTestGenerateIsReachableClass* requestClass)
+{
+    GObjectClass* gobjectClass = G_OBJECT_CLASS(requestClass);
+    g_type_class_add_private(gobjectClass, sizeof(WebKitDOMTestGenerateIsReachablePrivate));
+    gobjectClass->constructor = webkit_dom_test_generate_is_reachable_constructor;
+    gobjectClass->finalize = webkit_dom_test_generate_is_reachable_finalize;
+}
+
+static void webkit_dom_test_generate_is_reachable_init(WebKitDOMTestGenerateIsReachable* request)
+{
+    WebKitDOMTestGenerateIsReachablePrivate* priv = WEBKIT_DOM_TEST_GENERATE_IS_REACHABLE_GET_PRIVATE(request);
+    new (priv) WebKitDOMTestGenerateIsReachablePrivate();
+}
+
diff --git a/Source/WebCore/bindings/scripts/test/GObject/WebKitDOMTestGenerateIsReachable.h b/Source/WebCore/bindings/scripts/test/GObject/WebKitDOMTestGenerateIsReachable.h
new file mode 100644 (file)
index 0000000..cb560f3
--- /dev/null
@@ -0,0 +1,54 @@
+/*
+ *  This file is part of the WebKit open source project.
+ *  This file has been generated by generate-bindings.pl. DO NOT MODIFY!
+ *
+ *  This library is free software; you can redistribute it and/or
+ *  modify it under the terms of the GNU Library General Public
+ *  License as published by the Free Software Foundation; either
+ *  version 2 of the License, or (at your option) any later version.
+ *
+ *  This library is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ *  Library General Public License for more details.
+ *
+ *  You should have received a copy of the GNU Library General Public License
+ *  along with this library; see the file COPYING.LIB.  If not, write to
+ *  the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ *  Boston, MA 02110-1301, USA.
+ */
+
+#if !defined(__WEBKITDOM_H_INSIDE__) && !defined(BUILDING_WEBKIT)
+#error "Only <webkitdom/webkitdom.h> can be included directly."
+#endif
+
+#ifndef WebKitDOMTestGenerateIsReachable_h
+#define WebKitDOMTestGenerateIsReachable_h
+
+#include <glib-object.h>
+#include <webkitdom/WebKitDOMObject.h>
+#include <webkitdom/webkitdomdefines.h>
+
+G_BEGIN_DECLS
+
+#define WEBKIT_TYPE_DOM_TEST_GENERATE_IS_REACHABLE            (webkit_dom_test_generate_is_reachable_get_type())
+#define WEBKIT_DOM_TEST_GENERATE_IS_REACHABLE(obj)            (G_TYPE_CHECK_INSTANCE_CAST((obj), WEBKIT_TYPE_DOM_TEST_GENERATE_IS_REACHABLE, WebKitDOMTestGenerateIsReachable))
+#define WEBKIT_DOM_TEST_GENERATE_IS_REACHABLE_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST((klass),  WEBKIT_TYPE_DOM_TEST_GENERATE_IS_REACHABLE, WebKitDOMTestGenerateIsReachableClass)
+#define WEBKIT_DOM_IS_TEST_GENERATE_IS_REACHABLE(obj)         (G_TYPE_CHECK_INSTANCE_TYPE((obj), WEBKIT_TYPE_DOM_TEST_GENERATE_IS_REACHABLE))
+#define WEBKIT_DOM_IS_TEST_GENERATE_IS_REACHABLE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass),  WEBKIT_TYPE_DOM_TEST_GENERATE_IS_REACHABLE))
+#define WEBKIT_DOM_TEST_GENERATE_IS_REACHABLE_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS((obj),  WEBKIT_TYPE_DOM_TEST_GENERATE_IS_REACHABLE, WebKitDOMTestGenerateIsReachableClass))
+
+struct _WebKitDOMTestGenerateIsReachable {
+    WebKitDOMObject parent_instance;
+};
+
+struct _WebKitDOMTestGenerateIsReachableClass {
+    WebKitDOMObjectClass parent_class;
+};
+
+WEBKIT_API GType
+webkit_dom_test_generate_is_reachable_get_type (void);
+
+G_END_DECLS
+
+#endif /* WebKitDOMTestGenerateIsReachable_h */
diff --git a/Source/WebCore/bindings/scripts/test/GObject/WebKitDOMTestGenerateIsReachablePrivate.h b/Source/WebCore/bindings/scripts/test/GObject/WebKitDOMTestGenerateIsReachablePrivate.h
new file mode 100644 (file)
index 0000000..bb4d5cc
--- /dev/null
@@ -0,0 +1,33 @@
+/*
+ *  This file is part of the WebKit open source project.
+ *  This file has been generated by generate-bindings.pl. DO NOT MODIFY!
+ *
+ *  This library is free software; you can redistribute it and/or
+ *  modify it under the terms of the GNU Library General Public
+ *  License as published by the Free Software Foundation; either
+ *  version 2 of the License, or (at your option) any later version.
+ *
+ *  This library is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ *  Library General Public License for more details.
+ *
+ *  You should have received a copy of the GNU Library General Public License
+ *  along with this library; see the file COPYING.LIB.  If not, write to
+ *  the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ *  Boston, MA 02110-1301, USA.
+ */
+
+#ifndef WebKitDOMTestGenerateIsReachablePrivate_h
+#define WebKitDOMTestGenerateIsReachablePrivate_h
+
+#include "TestGenerateIsReachable.h"
+#include <webkitdom/WebKitDOMTestGenerateIsReachable.h>
+
+namespace WebKit {
+WebKitDOMTestGenerateIsReachable* wrapTestGenerateIsReachable(WebCore::TestGenerateIsReachable*);
+WebKitDOMTestGenerateIsReachable* kit(WebCore::TestGenerateIsReachable*);
+WebCore::TestGenerateIsReachable* core(WebKitDOMTestGenerateIsReachable*);
+} // namespace WebKit
+
+#endif /* WebKitDOMTestGenerateIsReachablePrivate_h */
index f0c9fb0..4c22c85 100644 (file)
@@ -191,13 +191,6 @@ EncodedJSValue JSC_HOST_CALL jsTestActiveDOMObjectPrototypeFunctionPostMessage(E
     return JSValue::encode(jsUndefined());
 }
 
-static inline bool isObservable(JSTestActiveDOMObject* jsTestActiveDOMObject)
-{
-    if (jsTestActiveDOMObject->hasCustomProperties())
-        return true;
-    return false;
-}
-
 bool JSTestActiveDOMObjectOwner::isReachableFromOpaqueRoots(JSC::Handle<JSC::Unknown> handle, void*, SlotVisitor& visitor)
 {
     UNUSED_PARAM(handle);
index 47c3c9c..2186ecd 100644 (file)
@@ -172,13 +172,6 @@ EncodedJSValue JSC_HOST_CALL jsTestCustomNamedGetterPrototypeFunctionAnotherFunc
     return JSValue::encode(jsUndefined());
 }
 
-static inline bool isObservable(JSTestCustomNamedGetter* jsTestCustomNamedGetter)
-{
-    if (jsTestCustomNamedGetter->hasCustomProperties())
-        return true;
-    return false;
-}
-
 bool JSTestCustomNamedGetterOwner::isReachableFromOpaqueRoots(JSC::Handle<JSC::Unknown> handle, void*, SlotVisitor& visitor)
 {
     UNUSED_PARAM(handle);
index eb48067..6908fae 100644 (file)
@@ -198,13 +198,6 @@ JSValue JSTestEventConstructor::getConstructor(VM& vm, JSGlobalObject* globalObj
     return getDOMConstructor<JSTestEventConstructorConstructor>(vm, jsCast<JSDOMGlobalObject*>(globalObject));
 }
 
-static inline bool isObservable(JSTestEventConstructor* jsTestEventConstructor)
-{
-    if (jsTestEventConstructor->hasCustomProperties())
-        return true;
-    return false;
-}
-
 bool JSTestEventConstructorOwner::isReachableFromOpaqueRoots(JSC::Handle<JSC::Unknown> handle, void*, SlotVisitor& visitor)
 {
     UNUSED_PARAM(handle);
index f8ad3d8..46a51a8 100644 (file)
@@ -279,15 +279,6 @@ JSValue JSTestEventTarget::indexGetter(ExecState* exec, JSValue slotBase, unsign
     return toJS(exec, thisObj->globalObject(), thisObj->impl().item(index));
 }
 
-static inline bool isObservable(JSTestEventTarget* jsTestEventTarget)
-{
-    if (jsTestEventTarget->hasCustomProperties())
-        return true;
-    if (jsTestEventTarget->impl().hasEventListeners())
-        return true;
-    return false;
-}
-
 bool JSTestEventTargetOwner::isReachableFromOpaqueRoots(JSC::Handle<JSC::Unknown> handle, void*, SlotVisitor& visitor)
 {
     JSTestEventTarget* jsTestEventTarget = jsCast<JSTestEventTarget*>(handle.get().asCell());
index 2891eb3..805990a 100644 (file)
@@ -141,13 +141,6 @@ JSValue JSTestException::getConstructor(VM& vm, JSGlobalObject* globalObject)
     return getDOMConstructor<JSTestExceptionConstructor>(vm, jsCast<JSDOMGlobalObject*>(globalObject));
 }
 
-static inline bool isObservable(JSTestException* jsTestException)
-{
-    if (jsTestException->hasCustomProperties())
-        return true;
-    return false;
-}
-
 bool JSTestExceptionOwner::isReachableFromOpaqueRoots(JSC::Handle<JSC::Unknown> handle, void*, SlotVisitor& visitor)
 {
     UNUSED_PARAM(handle);
diff --git a/Source/WebCore/bindings/scripts/test/JS/JSTestGenerateIsReachable.cpp b/Source/WebCore/bindings/scripts/test/JS/JSTestGenerateIsReachable.cpp
new file mode 100644 (file)
index 0000000..e378759
--- /dev/null
@@ -0,0 +1,197 @@
+/*
+    This file is part of the WebKit open source project.
+    This file has been generated by generate-bindings.pl. DO NOT MODIFY!
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Library General Public
+    License as published by the Free Software Foundation; either
+    version 2 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Library General Public License for more details.
+
+    You should have received a copy of the GNU Library General Public License
+    along with this library; see the file COPYING.LIB.  If not, write to
+    the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+    Boston, MA 02110-1301, USA.
+*/
+
+#include "config.h"
+#include "JSTestGenerateIsReachable.h"
+
+#include "TestGenerateIsReachable.h"
+#include <wtf/GetPtr.h>
+
+using namespace JSC;
+
+namespace WebCore {
+
+/* Hash table */
+
+static const HashTableValue JSTestGenerateIsReachableTableValues[] =
+{
+    { "constructor", DontEnum | ReadOnly, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestGenerateIsReachableConstructor), (intptr_t)0 },
+    { 0, 0, NoIntrinsic, 0, 0 }
+};
+
+static const HashTable JSTestGenerateIsReachableTable = { 2, 1, JSTestGenerateIsReachableTableValues, 0 };
+/* Hash table for constructor */
+
+static const HashTableValue JSTestGenerateIsReachableConstructorTableValues[] =
+{
+    { 0, 0, NoIntrinsic, 0, 0 }
+};
+
+static const HashTable JSTestGenerateIsReachableConstructorTable = { 1, 0, JSTestGenerateIsReachableConstructorTableValues, 0 };
+const ClassInfo JSTestGenerateIsReachableConstructor::s_info = { "TestGenerateIsReachableConstructor", &Base::s_info, &JSTestGenerateIsReachableConstructorTable, 0, CREATE_METHOD_TABLE(JSTestGenerateIsReachableConstructor) };
+
+JSTestGenerateIsReachableConstructor::JSTestGenerateIsReachableConstructor(Structure* structure, JSDOMGlobalObject* globalObject)
+    : DOMConstructorObject(structure, globalObject)
+{
+}
+
+void JSTestGenerateIsReachableConstructor::finishCreation(VM& vm, JSDOMGlobalObject* globalObject)
+{
+    Base::finishCreation(vm);
+    ASSERT(inherits(info()));
+    putDirect(vm, vm.propertyNames->prototype, JSTestGenerateIsReachablePrototype::self(vm, globalObject), DontDelete | ReadOnly);
+    putDirect(vm, vm.propertyNames->length, jsNumber(0), ReadOnly | DontDelete | DontEnum);
+}
+
+bool JSTestGenerateIsReachableConstructor::getOwnPropertySlot(JSObject* object, ExecState* exec, PropertyName propertyName, PropertySlot& slot)
+{
+    return getStaticValueSlot<JSTestGenerateIsReachableConstructor, JSDOMWrapper>(exec, JSTestGenerateIsReachableConstructorTable, jsCast<JSTestGenerateIsReachableConstructor*>(object), propertyName, slot);
+}
+
+/* Hash table for prototype */
+
+static const HashTableValue JSTestGenerateIsReachablePrototypeTableValues[] =
+{
+    { 0, 0, NoIntrinsic, 0, 0 }
+};
+
+static const HashTable JSTestGenerateIsReachablePrototypeTable = { 1, 0, JSTestGenerateIsReachablePrototypeTableValues, 0 };
+const ClassInfo JSTestGenerateIsReachablePrototype::s_info = { "TestGenerateIsReachablePrototype", &Base::s_info, &JSTestGenerateIsReachablePrototypeTable, 0, CREATE_METHOD_TABLE(JSTestGenerateIsReachablePrototype) };
+
+JSObject* JSTestGenerateIsReachablePrototype::self(VM& vm, JSGlobalObject* globalObject)
+{
+    return getDOMPrototype<JSTestGenerateIsReachable>(vm, globalObject);
+}
+
+const ClassInfo JSTestGenerateIsReachable::s_info = { "TestGenerateIsReachable", &Base::s_info, &JSTestGenerateIsReachableTable, 0 , CREATE_METHOD_TABLE(JSTestGenerateIsReachable) };
+
+JSTestGenerateIsReachable::JSTestGenerateIsReachable(Structure* structure, JSDOMGlobalObject* globalObject, PassRefPtr<TestGenerateIsReachable> impl)
+    : JSDOMWrapper(structure, globalObject)
+    , m_impl(impl.leakRef())
+{
+}
+
+void JSTestGenerateIsReachable::finishCreation(VM& vm)
+{
+    Base::finishCreation(vm);
+    ASSERT(inherits(info()));
+}
+
+JSObject* JSTestGenerateIsReachable::createPrototype(VM& vm, JSGlobalObject* globalObject)
+{
+    return JSTestGenerateIsReachablePrototype::create(vm, globalObject, JSTestGenerateIsReachablePrototype::createStructure(vm, globalObject, globalObject->objectPrototype()));
+}
+
+void JSTestGenerateIsReachable::destroy(JSC::JSCell* cell)
+{
+    JSTestGenerateIsReachable* thisObject = static_cast<JSTestGenerateIsReachable*>(cell);
+    thisObject->JSTestGenerateIsReachable::~JSTestGenerateIsReachable();
+}
+
+JSTestGenerateIsReachable::~JSTestGenerateIsReachable()
+{
+    releaseImplIfNotNull();
+}
+
+bool JSTestGenerateIsReachable::getOwnPropertySlot(JSObject* object, ExecState* exec, PropertyName propertyName, PropertySlot& slot)
+{
+    JSTestGenerateIsReachable* thisObject = jsCast<JSTestGenerateIsReachable*>(object);
+    ASSERT_GC_OBJECT_INHERITS(thisObject, info());
+    return getStaticValueSlot<JSTestGenerateIsReachable, Base>(exec, JSTestGenerateIsReachableTable, thisObject, propertyName, slot);
+}
+
+JSValue jsTestGenerateIsReachableConstructor(ExecState* exec, JSValue slotBase, PropertyName)
+{
+    JSTestGenerateIsReachable* domObject = jsCast<JSTestGenerateIsReachable*>(asObject(slotBase));
+    return JSTestGenerateIsReachable::getConstructor(exec->vm(), domObject->globalObject());
+}
+
+JSValue JSTestGenerateIsReachable::getConstructor(VM& vm, JSGlobalObject* globalObject)
+{
+    return getDOMConstructor<JSTestGenerateIsReachableConstructor>(vm, jsCast<JSDOMGlobalObject*>(globalObject));
+}
+
+static inline bool isObservable(JSTestGenerateIsReachable* jsTestGenerateIsReachable)
+{
+    if (jsTestGenerateIsReachable->hasCustomProperties())
+        return true;
+    return false;
+}
+
+bool JSTestGenerateIsReachableOwner::isReachableFromOpaqueRoots(JSC::Handle<JSC::Unknown> handle, void*, SlotVisitor& visitor)
+{
+    JSTestGenerateIsReachable* jsTestGenerateIsReachable = jsCast<JSTestGenerateIsReachable*>(handle.get().asCell());
+    if (!isObservable(jsTestGenerateIsReachable))
+        return false;
+    TestGenerateIsReachable* root = &jsTestGenerateIsReachable->impl();
+    return visitor.containsOpaqueRoot(root);
+}
+
+void JSTestGenerateIsReachableOwner::finalize(JSC::Handle<JSC::Unknown> handle, void* context)
+{
+    JSTestGenerateIsReachable* jsTestGenerateIsReachable = jsCast<JSTestGenerateIsReachable*>(handle.get().asCell());
+    DOMWrapperWorld& world = *static_cast<DOMWrapperWorld*>(context);
+    uncacheWrapper(world, &jsTestGenerateIsReachable->impl(), jsTestGenerateIsReachable);
+    jsTestGenerateIsReachable->releaseImpl();
+}
+
+#if ENABLE(BINDING_INTEGRITY)
+#if PLATFORM(WIN)
+#pragma warning(disable: 4483)
+extern "C" { extern void (*const __identifier("??_7TestGenerateIsReachable@WebCore@@6B@")[])(); }
+#else
+extern "C" { extern void* _ZTVN7WebCore23TestGenerateIsReachableE[]; }
+#endif
+#endif
+JSC::JSValue toJS(JSC::ExecState* exec, JSDOMGlobalObject* globalObject, TestGenerateIsReachable* impl)
+{
+    if (!impl)
+        return jsNull();
+    if (JSValue result = getExistingWrapper<JSTestGenerateIsReachable>(exec, impl))
+        return result;
+
+#if ENABLE(BINDING_INTEGRITY)
+    void* actualVTablePointer = *(reinterpret_cast<void**>(impl));
+#if PLATFORM(WIN)
+    void* expectedVTablePointer = reinterpret_cast<void*>(__identifier("??_7TestGenerateIsReachable@WebCore@@6B@"));
+#else
+    void* expectedVTablePointer = &_ZTVN7WebCore23TestGenerateIsReachableE[2];
+#if COMPILER(CLANG)
+    // If this fails TestGenerateIsReachable does not have a vtable, so you need to add the
+    // ImplementationLacksVTable attribute to the interface definition
+    COMPILE_ASSERT(__is_polymorphic(TestGenerateIsReachable), TestGenerateIsReachable_is_not_polymorphic);
+#endif
+#endif
+    // If you hit this assertion you either have a use after free bug, or
+    // TestGenerateIsReachable has subclasses. If TestGenerateIsReachable has subclasses that get passed
+    // to toJS() we currently require TestGenerateIsReachable you to opt out of binding hardening
+    // by adding the SkipVTableValidation attribute to the interface IDL definition
+    RELEASE_ASSERT(actualVTablePointer == expectedVTablePointer);
+#endif
+    ReportMemoryCost<TestGenerateIsReachable>::reportMemoryCost(exec, impl);
+    return createNewWrapper<JSTestGenerateIsReachable>(exec, globalObject, impl);
+}
+
+TestGenerateIsReachable* toTestGenerateIsReachable(JSC::JSValue value)
+{
+    return value.inherits(JSTestGenerateIsReachable::info()) ? &jsCast<JSTestGenerateIsReachable*>(asObject(value))->impl() : 0;
+}
+
+}
diff --git a/Source/WebCore/bindings/scripts/test/JS/JSTestGenerateIsReachable.h b/Source/WebCore/bindings/scripts/test/JS/JSTestGenerateIsReachable.h
new file mode 100644 (file)
index 0000000..f11f997
--- /dev/null
@@ -0,0 +1,146 @@
+/*
+    This file is part of the WebKit open source project.
+    This file has been generated by generate-bindings.pl. DO NOT MODIFY!
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Library General Public
+    License as published by the Free Software Foundation; either
+    version 2 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Library General Public License for more details.
+
+    You should have received a copy of the GNU Library General Public License
+    along with this library; see the file COPYING.LIB.  If not, write to
+    the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+    Boston, MA 02110-1301, USA.
+*/
+
+#ifndef JSTestGenerateIsReachable_h
+#define JSTestGenerateIsReachable_h
+
+#include "JSDOMBinding.h"
+#include "TestGenerateIsReachable.h"
+#include <runtime/JSGlobalObject.h>
+#include <runtime/JSObject.h>
+#include <runtime/ObjectPrototype.h>
+
+namespace WebCore {
+
+class JSTestGenerateIsReachable : public JSDOMWrapper {
+public:
+    typedef JSDOMWrapper Base;
+    static JSTestGenerateIsReachable* create(JSC::Structure* structure, JSDOMGlobalObject* globalObject, PassRefPtr<TestGenerateIsReachable> impl)
+    {
+        JSTestGenerateIsReachable* ptr = new (NotNull, JSC::allocateCell<JSTestGenerateIsReachable>(globalObject->vm().heap)) JSTestGenerateIsReachable(structure, globalObject, impl);
+        ptr->finishCreation(globalObject->vm());
+        return ptr;
+    }
+
+    static JSC::JSObject* createPrototype(JSC::VM&, JSC::JSGlobalObject*);
+    static bool getOwnPropertySlot(JSC::JSObject*, JSC::ExecState*, JSC::PropertyName, JSC::PropertySlot&);
+    static void destroy(JSC::JSCell*);
+    ~JSTestGenerateIsReachable();
+    DECLARE_INFO;
+
+    static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)
+    {
+        return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(JSC::ObjectType, StructureFlags), info());
+    }
+
+    static JSC::JSValue getConstructor(JSC::VM&, JSC::JSGlobalObject*);
+    TestGenerateIsReachable& impl() const { return *m_impl; }
+    void releaseImpl() { m_impl->deref(); m_impl = 0; }
+
+    void releaseImplIfNotNull()
+    {
+        if (m_impl) {
+            m_impl->deref();
+            m_impl = 0;
+        }
+    }
+
+private:
+    TestGenerateIsReachable* m_impl;
+protected:
+    JSTestGenerateIsReachable(JSC::Structure*, JSDOMGlobalObject*, PassRefPtr<TestGenerateIsReachable>);
+    void finishCreation(JSC::VM&);
+    static const unsigned StructureFlags = JSC::OverridesGetOwnPropertySlot | JSC::InterceptsGetOwnPropertySlotByIndexEvenWhenLengthIsNotZero | Base::StructureFlags;
+};
+
+class JSTestGenerateIsReachableOwner : public JSC::WeakHandleOwner {
+public:
+    virtual bool isReachableFromOpaqueRoots(JSC::Handle<JSC::Unknown>, void* context, JSC::SlotVisitor&);
+    virtual void finalize(JSC::Handle<JSC::Unknown>, void* context);
+};
+
+inline JSC::WeakHandleOwner* wrapperOwner(DOMWrapperWorld&, TestGenerateIsReachable*)
+{
+    DEFINE_STATIC_LOCAL(JSTestGenerateIsReachableOwner, jsTestGenerateIsReachableOwner, ());
+    return &jsTestGenerateIsReachableOwner;
+}
+
+inline void* wrapperContext(DOMWrapperWorld& world, TestGenerateIsReachable*)
+{
+    return &world;
+}
+
+JSC::JSValue toJS(JSC::ExecState*, JSDOMGlobalObject*, TestGenerateIsReachable*);
+TestGenerateIsReachable* toTestGenerateIsReachable(JSC::JSValue);
+
+class JSTestGenerateIsReachablePrototype : public JSC::JSNonFinalObject {
+public:
+    typedef JSC::JSNonFinalObject Base;
+    static JSC::JSObject* self(JSC::VM&, JSC::JSGlobalObject*);
+    static JSTestGenerateIsReachablePrototype* create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure)
+    {
+        JSTestGenerateIsReachablePrototype* ptr = new (NotNull, JSC::allocateCell<JSTestGenerateIsReachablePrototype>(vm.heap)) JSTestGenerateIsReachablePrototype(vm, globalObject, structure);
+        ptr->finishCreation(vm);
+        return ptr;
+    }
+
+    DECLARE_INFO;
+    static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)
+    {
+        return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(JSC::ObjectType, StructureFlags), info());
+    }
+
+private:
+    JSTestGenerateIsReachablePrototype(JSC::VM& vm, JSC::JSGlobalObject*, JSC::Structure* structure) : JSC::JSNonFinalObject(vm, structure) { }
+protected:
+    static const unsigned StructureFlags = Base::StructureFlags;
+};
+
+class JSTestGenerateIsReachableConstructor : public DOMConstructorObject {
+private:
+    JSTestGenerateIsReachableConstructor(JSC::Structure*, JSDOMGlobalObject*);
+    void finishCreation(JSC::VM&, JSDOMGlobalObject*);
+
+public:
+    typedef DOMConstructorObject Base;
+    static JSTestGenerateIsReachableConstructor* create(JSC::VM& vm, JSC::Structure* structure, JSDOMGlobalObject* globalObject)
+    {
+        JSTestGenerateIsReachableConstructor* ptr = new (NotNull, JSC::allocateCell<JSTestGenerateIsReachableConstructor>(vm.heap)) JSTestGenerateIsReachableConstructor(structure, globalObject);
+        ptr->finishCreation(vm, globalObject);
+        return ptr;
+    }
+
+    static bool getOwnPropertySlot(JSC::JSObject*, JSC::ExecState*, JSC::PropertyName, JSC::PropertySlot&);
+    DECLARE_INFO;
+    static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)
+    {
+        return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(JSC::ObjectType, StructureFlags), info());
+    }
+protected:
+    static const unsigned StructureFlags = JSC::OverridesGetOwnPropertySlot | JSC::ImplementsHasInstance | DOMConstructorObject::StructureFlags;
+};
+
+// Attributes
+
+JSC::JSValue jsTestGenerateIsReachableConstructor(JSC::ExecState*, JSC::JSValue, JSC::PropertyName);
+
+} // namespace WebCore
+
+#endif
index 100b5db..8f43d95 100644 (file)
@@ -700,13 +700,6 @@ JSValue jsTestInterfaceSUPPLEMENTALCONSTANT2(ExecState* exec, JSValue, PropertyN
 }
 
 #endif
-static inline bool isObservable(JSTestInterface* jsTestInterface)
-{
-    if (jsTestInterface->hasCustomProperties())
-        return true;
-    return false;
-}
-
 bool JSTestInterfaceOwner::isReachableFromOpaqueRoots(JSC::Handle<JSC::Unknown> handle, void*, SlotVisitor& visitor)
 {
     JSTestInterface* jsTestInterface = jsCast<JSTestInterface*>(handle.get().asCell());
index 362e6ab..982a293 100644 (file)
@@ -156,13 +156,6 @@ EncodedJSValue JSC_HOST_CALL jsTestMediaQueryListListenerPrototypeFunctionMethod
     return JSValue::encode(jsUndefined());
 }
 
-static inline bool isObservable(JSTestMediaQueryListListener* jsTestMediaQueryListListener)
-{
-    if (jsTestMediaQueryListListener->hasCustomProperties())
-        return true;
-    return false;
-}
-
 bool JSTestMediaQueryListListenerOwner::isReachableFromOpaqueRoots(JSC::Handle<JSC::Unknown> handle, void*, SlotVisitor& visitor)
 {
     UNUSED_PARAM(handle);
index d96a39f..c9a5afa 100644 (file)
@@ -180,13 +180,6 @@ JSValue JSTestNamedConstructor::getNamedConstructor(VM& vm, JSGlobalObject* glob
     return getDOMConstructor<JSTestNamedConstructorNamedConstructor>(vm, jsCast<JSDOMGlobalObject*>(globalObject));
 }
 
-static inline bool isObservable(JSTestNamedConstructor* jsTestNamedConstructor)
-{
-    if (jsTestNamedConstructor->hasCustomProperties())
-        return true;
-    return false;
-}
-
 bool JSTestNamedConstructorOwner::isReachableFromOpaqueRoots(JSC::Handle<JSC::Unknown> handle, void*, SlotVisitor& visitor)
 {
     JSTestNamedConstructor* jsTestNamedConstructor = jsCast<JSTestNamedConstructor*>(handle.get().asCell());
index f6c18cb..511a61d 100644 (file)
@@ -3306,13 +3306,6 @@ JSValue jsTestObjReadonly(ExecState* exec, JSValue, PropertyName)
     return jsNumber(static_cast<int>(0));
 }
 
-static inline bool isObservable(JSTestObj* jsTestObj)
-{
-    if (jsTestObj->hasCustomProperties())
-        return true;
-    return false;
-}
-
 bool JSTestObjOwner::isReachableFromOpaqueRoots(JSC::Handle<JSC::Unknown> handle, void*, SlotVisitor& visitor)
 {
     UNUSED_PARAM(handle);
index cc0a522..fd77794 100644 (file)
@@ -203,13 +203,6 @@ JSValue JSTestOverloadedConstructors::getConstructor(VM& vm, JSGlobalObject* glo
     return getDOMConstructor<JSTestOverloadedConstructorsConstructor>(vm, jsCast<JSDOMGlobalObject*>(globalObject));
 }
 
-static inline bool isObservable(JSTestOverloadedConstructors* jsTestOverloadedConstructors)
-{
-    if (jsTestOverloadedConstructors->hasCustomProperties())
-        return true;
-    return false;
-}
-
 bool JSTestOverloadedConstructorsOwner::isReachableFromOpaqueRoots(JSC::Handle<JSC::Unknown> handle, void*, SlotVisitor& visitor)
 {
     UNUSED_PARAM(handle);
index 7562d69..e29e3ec 100644 (file)
@@ -238,13 +238,6 @@ void JSTestSerializedScriptValueInterface::visitChildren(JSCell* cell, SlotVisit
     visitor.append(&thisObject->m_cachedReadonlyValue);
 }
 
-static inline bool isObservable(JSTestSerializedScriptValueInterface* jsTestSerializedScriptValueInterface)
-{
-    if (jsTestSerializedScriptValueInterface->hasCustomProperties())
-        return true;
-    return false;
-}
-
 bool JSTestSerializedScriptValueInterfaceOwner::isReachableFromOpaqueRoots(JSC::Handle<JSC::Unknown> handle, void*, SlotVisitor& visitor)
 {
     UNUSED_PARAM(handle);
index 5fe414e..22e1182 100644 (file)
@@ -559,13 +559,6 @@ EncodedJSValue JSC_HOST_CALL jsTestTypedefsPrototypeFunctionMethodWithException(
     return JSValue::encode(jsUndefined());
 }
 
-static inline bool isObservable(JSTestTypedefs* jsTestTypedefs)
-{
-    if (jsTestTypedefs->hasCustomProperties())
-        return true;
-    return false;
-}
-
 bool JSTestTypedefsOwner::isReachableFromOpaqueRoots(JSC::Handle<JSC::Unknown> handle, void*, SlotVisitor& visitor)
 {
     UNUSED_PARAM(handle);
index 38469a0..6f94e24 100644 (file)
@@ -141,13 +141,6 @@ JSValue JSattribute::getConstructor(VM& vm, JSGlobalObject* globalObject)
     return getDOMConstructor<JSattributeConstructor>(vm, jsCast<JSDOMGlobalObject*>(globalObject));
 }
 
-static inline bool isObservable(JSattribute* jsattribute)
-{
-    if (jsattribute->hasCustomProperties())
-        return true;
-    return false;
-}
-
 bool JSattributeOwner::isReachableFromOpaqueRoots(JSC::Handle<JSC::Unknown> handle, void*, SlotVisitor& visitor)
 {
     UNUSED_PARAM(handle);
index 4c4fe21..cd99215 100644 (file)
@@ -128,13 +128,6 @@ JSValue JSreadonly::getConstructor(VM& vm, JSGlobalObject* globalObject)
     return getDOMConstructor<JSreadonlyConstructor>(vm, jsCast<JSDOMGlobalObject*>(globalObject));
 }
 
-static inline bool isObservable(JSreadonly* jsreadonly)
-{
-    if (jsreadonly->hasCustomProperties())
-        return true;
-    return false;
-}
-
 bool JSreadonlyOwner::isReachableFromOpaqueRoots(JSC::Handle<JSC::Unknown> handle, void*, SlotVisitor& visitor)
 {
     UNUSED_PARAM(handle);
diff --git a/Source/WebCore/bindings/scripts/test/ObjC/DOMTestGenerateIsReachable.h b/Source/WebCore/bindings/scripts/test/ObjC/DOMTestGenerateIsReachable.h
new file mode 100644 (file)
index 0000000..ef967a4
--- /dev/null
@@ -0,0 +1,34 @@
+/*
+ * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009 Apple Inc. All rights reserved.
+ * Copyright (C) 2006 Samuel Weinig <sam.weinig@gmail.com>
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY APPLE COMPUTER, INC. ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE COMPUTER, INC. OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
+ * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
+ */
+
+#import <WebCore/DOMObject.h>
+
+#if WEBKIT_VERSION_MAX_ALLOWED >= WEBKIT_VERSION_LATEST
+
+@interface DOMTestGenerateIsReachable : DOMObject
+@end
+
+#endif
diff --git a/Source/WebCore/bindings/scripts/test/ObjC/DOMTestGenerateIsReachable.mm b/Source/WebCore/bindings/scripts/test/ObjC/DOMTestGenerateIsReachable.mm
new file mode 100644 (file)
index 0000000..d2278a1
--- /dev/null
@@ -0,0 +1,82 @@
+/*
+ * This file is part of the WebKit open source project.
+ * This file has been generated by generate-bindings.pl. DO NOT MODIFY!
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY APPLE COMPUTER, INC. ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE COMPUTER, INC. OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
+ * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
+ */
+
+#import "config.h"
+#import "DOMInternal.h"
+
+#import "DOMTestGenerateIsReachable.h"
+
+#import "DOMNodeInternal.h"
+#import "DOMTestGenerateIsReachableInternal.h"
+#import "ExceptionHandlers.h"
+#import "JSMainThreadExecState.h"
+#import "TestGenerateIsReachable.h"
+#import "ThreadCheck.h"
+#import "WebCoreObjCExtras.h"
+#import "WebScriptObjectPrivate.h"
+#import <wtf/GetPtr.h>
+
+#define IMPL reinterpret_cast<WebCore::TestGenerateIsReachable*>(_internal)
+
+@implementation DOMTestGenerateIsReachable
+
+- (void)dealloc
+{
+    if (WebCoreObjCScheduleDeallocateOnMainThread([DOMTestGenerateIsReachable class], self))
+        return;
+
+    if (_internal)
+        IMPL->deref();
+    [super dealloc];
+}
+
+- (void)finalize
+{
+    if (_internal)
+        IMPL->deref();
+    [super finalize];
+}
+
+@end
+
+WebCore::TestGenerateIsReachable* core(DOMTestGenerateIsReachable *wrapper)
+{
+    return wrapper ? reinterpret_cast<WebCore::TestGenerateIsReachable*>(wrapper->_internal) : 0;
+}
+
+DOMTestGenerateIsReachable *kit(WebCore::TestGenerateIsReachable* value)
+{
+    { DOM_ASSERT_MAIN_THREAD(); WebCoreThreadViolationCheckRoundOne(); };
+    if (!value)
+        return nil;
+    if (DOMTestGenerateIsReachable *wrapper = getDOMWrapper(value))
+        return [[wrapper retain] autorelease];
+    DOMTestGenerateIsReachable *wrapper = [[DOMTestGenerateIsReachable alloc] _init];
+    wrapper->_internal = reinterpret_cast<DOMObjectInternal*>(value);
+    value->ref();
+    addDOMWrapper(wrapper, value);
+    return [wrapper autorelease];
+}
diff --git a/Source/WebCore/bindings/scripts/test/ObjC/DOMTestGenerateIsReachableInternal.h b/Source/WebCore/bindings/scripts/test/ObjC/DOMTestGenerateIsReachableInternal.h
new file mode 100644 (file)
index 0000000..6d9176a
--- /dev/null
@@ -0,0 +1,38 @@
+/*
+ * This file is part of the WebKit open source project.
+ * This file has been generated by generate-bindings.pl. DO NOT MODIFY!
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY APPLE COMPUTER, INC. ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE COMPUTER, INC. OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
+ * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
+ */
+
+#import <WebCore/DOMTestGenerateIsReachable.h>
+
+#if WEBKIT_VERSION_MAX_ALLOWED >= WEBKIT_VERSION_LATEST
+
+namespace WebCore {
+class TestGenerateIsReachable;
+}
+
+WebCore::TestGenerateIsReachable* core(DOMTestGenerateIsReachable *);
+DOMTestGenerateIsReachable *kit(WebCore::TestGenerateIsReachable*);
+
+#endif
diff --git a/Source/WebCore/bindings/scripts/test/TestGenerateIsReachable.idl b/Source/WebCore/bindings/scripts/test/TestGenerateIsReachable.idl
new file mode 100644 (file)
index 0000000..0945808
--- /dev/null
@@ -0,0 +1,30 @@
+/*
+ * Copyright (C) 2013 Apple 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:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE INC. OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
+ * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
+ */
+
+[
+    GenerateIsReachable=Impl,
+] interface TestGenerateIsReachable {
+};
+