Merge 132922 - Remove ensureAuxiliaryContext

Source/WebCore/bindings/v8/IDBBindingUtilities.cpp

 /*
  * Copyright (C) 2011 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:
  *
  * 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
@@ skipping 161 matching lines @@
 
     return currentValue;
 }
 
 static PassRefPtr<IDBKey> createIDBKeyFromScriptValueAndKeyPath(const ScriptValue& value, const String& keyPath)
 {
     Vector<String> keyPathElements;
     IDBKeyPathParseError error;
     IDBParseKeyPath(keyPath, keyPathElements, error);
     ASSERT(error == IDBKeyPathParseErrorNone);
+    ASSERT(v8::Context::InContext());
 
     v8::HandleScope handleScope;
-    v8::Context::Scope scope(V8PerIsolateData::current()->ensureAuxiliaryContext());
-
     v8::Handle<v8::Value> v8Value(value.v8Value());
     v8::Handle<v8::Value> v8Key(getNthValueOnKeyPath(v8Value, keyPathElements, keyPathElements.size()));
     if (v8Key.IsEmpty())
         return 0;
     return createIDBKeyFromValue(v8Key);
 }
 
 PassRefPtr<IDBKey> createIDBKeyFromScriptValueAndKeyPath(const ScriptValue& value, const IDBKeyPath& keyPath)
 {
     IDB_TRACE("createIDBKeyFromScriptValueAndKeyPath");
     ASSERT(!keyPath.isNull());
+    ASSERT(v8::Context::InContext());
 
-    v8::HandleScope scope;
+
+    v8::HandleScope handleScope;
     if (keyPath.type() == IDBKeyPath::ArrayType) {
         IDBKey::KeyArray result;
         const Vector<String>& array = keyPath.array();
         for (size_t i = 0; i < array.size(); ++i) {
             RefPtr<IDBKey> key = createIDBKeyFromScriptValueAndKeyPath(value, array[i]);
             if (!key)
                 return 0;
             result.append(key);
         }
         return IDBKey::createArray(result);
     }
 
     ASSERT(keyPath.type() == IDBKeyPath::StringType);
     return createIDBKeyFromScriptValueAndKeyPath(value, keyPath.string());
 }
 
-// FIXME: The only reason this exists is because we need a v8::Context and scope inside a timer. Is there a better / more general way to do this?
 ScriptValue deserializeIDBValue(ScriptExecutionContext* scriptContext, PassRefPtr<SerializedScriptValue> prpValue)
 {
+    ASSERT(v8::Context::InContext());
     v8::HandleScope handleScope;
-    v8::Context::Scope contextScope(toV8Context(scriptContext, UseCurrentWorld));
     RefPtr<SerializedScriptValue> serializedValue = prpValue;
     if (serializedValue)
         return ScriptValue(serializedValue->deserialize());
     return ScriptValue(v8::Null());
 }
 
 bool injectIDBKeyIntoScriptValue(PassRefPtr<IDBKey> key, ScriptValue& value, const IDBKeyPath& keyPath)
 {
     IDB_TRACE("injectIDBKeyIntoScriptValue");
+    ASSERT(v8::Context::InContext());
 
     ASSERT(keyPath.type() == IDBKeyPath::StringType);
     Vector<String> keyPathElements;
     IDBKeyPathParseError error;
     IDBParseKeyPath(keyPath.string(), keyPathElements, error);
     ASSERT(error == IDBKeyPathParseErrorNone);
 
     if (!keyPathElements.size())
         return 0;
 
     v8::HandleScope handleScope;
-    v8::Context::Scope scope(V8PerIsolateData::current()->ensureAuxiliaryContext());
-
     v8::Handle<v8::Value> v8Value(value.v8Value());
     v8::Handle<v8::Value> parent(ensureNthValueOnKeyPath(v8Value, keyPathElements, keyPathElements.size() - 1));
     if (parent.IsEmpty())
         return false;
 
     if (!set(parent, keyPathElements.last(), toV8(key.get())))
         return false;
 
     return true;
 }
 
 bool canInjectIDBKeyIntoScriptValue(const ScriptValue& scriptValue, const IDBKeyPath& keyPath)
 {
     IDB_TRACE("canInjectIDBKeyIntoScriptValue");
     ASSERT(keyPath.type() == IDBKeyPath::StringType);
     Vector<String> keyPathElements;
     IDBKeyPathParseError error;
     IDBParseKeyPath(keyPath.string(), keyPathElements, error);
     ASSERT(error == IDBKeyPathParseErrorNone);
 
     if (!keyPathElements.size())
         return false;
 
     v8::Handle<v8::Value> v8Value(scriptValue.v8Value());
     return canInjectNthValueOnKeyPath(v8Value, keyPathElements, keyPathElements.size() - 1);
 }
 
 ScriptValue idbKeyToScriptValue(ScriptExecutionContext* scriptContext, PassRefPtr<IDBKey> key)
 {
+    ASSERT(v8::Context::InContext());
     v8::HandleScope handleScope;
-    v8::Context::Scope contextScope(toV8Context(scriptContext, UseCurrentWorld));
-
     v8::Handle<v8::Value> v8Value(toV8(key.get()));
     return ScriptValue(v8Value);
 }
 
 } // namespace WebCore
 
 #endif