Get rid of usages of ScriptWrappable::wrapper().

Source/bindings/v8/UnsafePersistent.h

 /*
  * Copyright (C) 2013 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 10 matching lines @@
  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  * OWNER 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.
  */
 
-#include "config.h"
-#include "modules/webmidi/MIDIErrorCallback.h"
+#ifndef UnsafePersistent_h
+#define UnsafePersistent_h
 
-#include "core/dom/DOMError.h"
-#include "core/dom/ScriptExecutionContext.h"
+#include <v8.h>
 
 namespace WebCore {
 
-namespace {
+// An unsafe way to pass Persistent handles around. Do not use unless you know
+// what you're doing. UnsafePersistent is only safe to use when we know that the
+// memory pointed by the it is not going away: 1) When GC cannot happen while
+// the UnsafePersistent is alive or 2) when there is a strong Persistent keeping
+// the memory alive while the UnsafePersistent is alive.
 
-class DispatchCallbackTask : public ScriptExecutionContext::Task {
+// TODO: assert that GC doesn't happen during the lifetime of UnsafePersistent.

[abarth-chromium, 2013/04/29 17:47:33]

TODO -> FIXME

[marja, 2013/04/30 08:55:50]

Done.

+template<typename T> class UnsafePersistent {

[abarth-chromium, 2013/04/29 17:47:33]

I probably would have called this class UnsafeHandle, but this name is fine too.

[marja, 2013/04/30 08:55:50]

After the future renaming, Local will be called Handle, so calling this
UnsafeHandle would be confusing.

 public:
-    static PassOwnPtr<DispatchCallbackTask> create(PassRefPtr<MIDIErrorCallback> callback, PassRefPtr<DOMError> error)
+    UnsafePersistent(T* value) : m_value(value) { }
+
+    // The end result is generally unsafe to use, see the class level comment
+    // for when it's safe to use.
+    void makePersistentHandle(v8::Persistent<T>* handle) const

[abarth-chromium, 2013/04/29 17:47:33]

copyTo ?

[marja, 2013/04/30 08:55:50]

Done.

     {
-        return adoptPtr(new DispatchCallbackTask(callback, error));
+        T** rawValue = reinterpret_cast<T**>(handle);

[abarth-chromium, 2013/04/29 17:47:33]

Wow, that's scary stuff.

+        *rawValue = m_value;
     }
 
-    virtual void performTask(ScriptExecutionContext*)
+    T* value() const
     {
-        m_callback->handleEvent(m_error.get());
+        return m_value;
     }
 
 private:
-    DispatchCallbackTask(PassRefPtr<MIDIErrorCallback> callback, PassRefPtr<DOMError> error)
-            : m_callback(callback)
-            , m_error(error)
-    {
-    }
-
-    RefPtr<MIDIErrorCallback> m_callback;
-    RefPtr<DOMError> m_error;
+    T* m_value;
 };
 
-} // namespace
+} // namespace WebCore
 
-void MIDIErrorCallback::scheduleCallback(ScriptExecutionContext* context, PassRefPtr<DOMError> error)
-{
-    context->postTask(DispatchCallbackTask::create(this, error));
-}
-
-} // namespace WebCore
+#endif // UnsafePersistent_h