Implement IDBVersionChangeEvent ctor w/ IDBVersionChangeEventInit dict

Source/bindings/v8/SerializedScriptValue.cpp

 /*
  * 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 2278 matching lines @@
     return adoptRef(new SerializedScriptValue(wireData));
 }
 
 PassRefPtr<SerializedScriptValue> SerializedScriptValue::create()
 {
     return adoptRef(new SerializedScriptValue());
 }
 
 PassRefPtr<SerializedScriptValue> SerializedScriptValue::nullValue()
 {
-    return nullValue(v8::Isolate::GetCurrent());
-}
-
-PassRefPtr<SerializedScriptValue> SerializedScriptValue::nullValue(v8::Isolate* isolate)
-{
+    v8::Isolate* isolate = 0;

[haraken, 2014/02/25 01:14:38]

I'm not really happy about this.

When we have an Isolate*, we want to assume that the Isolate* is non-NULL.
(We've eliminated almost all NULL Isolate* from the code base.)

If Writer starts using the maybe-NULL isolate in the future, it will cause
crashes since other code expects a non-NULL isolate.

Shall we pass an Isolate to nullValue() or keep v8::Isolate::GetCurrent()? I
agree that we should remove v8::Isolate::GetCurrent() but I think that
v8::Isolate::GetCurrent() is better than using 0.

[jsbell, 2014/02/25 17:42:10]

Okay. Since this is just packing bytes into a buffer using the writer, there's
no need for an isolate. It seemed like with tests for these cases (static
xxxValue() constructors) tests would catch any mistakes - it should have unit
tests at the very least, though. That would complicate further reworking of SSV,
though, so I understand if we want to avoid that.
 
The sites that construct a new IDBVersionChangeEvent do so without v8 on the
stack. In the current (IDBAny) approach, creating the new v8 value is deferred
until script accesses the property. In this patch, the SSV is used to defer the
creation instead.

I'll ponder.

     Writer writer(isolate);
     writer.writeNull();
     String wireData = writer.takeWireString();
     return adoptRef(new SerializedScriptValue(wireData));
 }
+
+PassRefPtr<SerializedScriptValue> SerializedScriptValue::numberValue(double number)
+{
+    v8::Isolate* isolate = 0;

[haraken, 2014/02/25 01:14:38]

Ditto.

+    Writer writer(isolate);
+    writer.writeNumber(number);
+    String wireData = writer.takeWireString();
+    return adoptRef(new SerializedScriptValue(wireData));
+}
 
 // Convert serialized string to big endian wire data.
 void SerializedScriptValue::toWireBytes(Vector<char>& result) const
 {
     ASSERT(result.isEmpty());
     size_t length = m_data.length();
     result.resize(length * sizeof(UChar));
     UChar* dst = reinterpret_cast<UChar*>(result.data());
 
     if (m_data.is8Bit()) {
@@ skipping 133 matching lines @@
     // If the allocated memory was not registered before, then this class is likely
     // used in a context other then Worker's onmessage environment and the presence of
     // current v8 context is not guaranteed. Avoid calling v8 then.
     if (m_externallyAllocatedMemory) {
         ASSERT(v8::Isolate::GetCurrent());
         v8::Isolate::GetCurrent()->AdjustAmountOfExternalAllocatedMemory(-m_externallyAllocatedMemory);
     }
 }
 
 } // namespace WebCore