Pass isolate to v8::Local<>::New() factory function

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 924 matching lines @@
 
     protected:
         virtual StateBase* objectDone(unsigned numProperties, Serializer& serializer)
         {
             return serializer.writeObject(numProperties, this);
         }
     };
 
     class DenseArrayState : public AbstractObjectState {
     public:
-        DenseArrayState(v8::Handle<v8::Array> array, v8::Handle<v8::Array> propertyNames, StateBase* next)
+        DenseArrayState(v8::Handle<v8::Array> array, v8::Handle<v8::Array> propertyNames, StateBase* next, v8::Isolate* isolate)
             : AbstractObjectState(array, next)
             , m_arrayIndex(0)
             , m_arrayLength(array->Length())
         {
-            m_propertyNames = v8::Local<v8::Array>::New(propertyNames);
+            m_propertyNames = v8::Local<v8::Array>::New(isolate, propertyNames);
         }
 
         virtual StateBase* advance(Serializer& serializer)
         {
             while (m_arrayIndex < m_arrayLength) {
                 v8::Handle<v8::Value> value = composite().As<v8::Array>()->Get(m_arrayIndex);
                 m_arrayIndex++;
                 if (StateBase* newState = serializer.checkException(this))
                     return newState;
                 if (StateBase* newState = serializer.doSerialize(value, this))
                     return newState;
             }
             return serializeProperties(true, serializer);
         }
 
     protected:
         virtual StateBase* objectDone(unsigned numProperties, Serializer& serializer)
         {
             return serializer.writeDenseArray(numProperties, m_arrayLength, this);
         }
 
     private:
         uint32_t m_arrayIndex;
         uint32_t m_arrayLength;
     };
 
     class SparseArrayState : public AbstractObjectState {
     public:
-        SparseArrayState(v8::Handle<v8::Array> array, v8::Handle<v8::Array> propertyNames, StateBase* next)
+        SparseArrayState(v8::Handle<v8::Array> array, v8::Handle<v8::Array> propertyNames, StateBase* next, v8::Isolate* isolate)
             : AbstractObjectState(array, next)
         {
-            m_propertyNames = v8::Local<v8::Array>::New(propertyNames);
+            m_propertyNames = v8::Local<v8::Array>::New(isolate, propertyNames);
         }
 
         virtual StateBase* advance(Serializer& serializer)
         {
             return serializeProperties(false, serializer);
         }
 
     protected:
         virtual StateBase* objectDone(unsigned numProperties, Serializer& serializer)
         {
@@ skipping 199 matching lines @@
 
     StateBase* startArrayState(v8::Handle<v8::Array> array, StateBase* next)
     {
         v8::Handle<v8::Array> propertyNames = array->GetPropertyNames();
         if (StateBase* newState = checkException(next))
             return newState;
         uint32_t length = array->Length();
 
         if (shouldSerializeDensely(length, propertyNames->Length())) {
             m_writer.writeGenerateFreshDenseArray(length);
-            return push(new DenseArrayState(array, propertyNames, next));
+            return push(new DenseArrayState(array, propertyNames, next, m_isolate));
         }
 
         m_writer.writeGenerateFreshSparseArray(length);
-        return push(new SparseArrayState(array, propertyNames, next));
+        return push(new SparseArrayState(array, propertyNames, next, m_isolate));
     }
 
     StateBase* startObjectState(v8::Handle<v8::Object> object, StateBase* next)
     {
         m_writer.writeGenerateFreshObject();
         // FIXME: check not a wrapper
         return push(new ObjectState(object, next));
     }
 
     // Marks object as having been visited by the serializer and assigns it a unique object reference ID.
@@ skipping 1317 matching lines @@
         v8::V8::AdjustAmountOfExternalAllocatedMemory(-m_externallyAllocatedMemory);
     }
 }
 
 uint32_t SerializedScriptValue::wireFormatVersion()
 {
     return WebCore::wireFormatVersion;
 }
 
 } // namespace WebCore