Merge 132922 - Remove ensureAuxiliaryContext

Source/WebCore/Modules/indexeddb/IDBRequest.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:
  *
  * 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 24 matching lines @@
 #include "EventListener.h"
 #include "EventNames.h"
 #include "EventQueue.h"
 #include "IDBBindingUtilities.h"
 #include "IDBCursorWithValue.h"
 #include "IDBDatabase.h"
 #include "IDBEventDispatcher.h"
 #include "IDBTracing.h"
 #include "IDBTransaction.h"
 #include "ScriptExecutionContext.h"
+#if USE(V8)
+#include "V8Binding.h"
+#endif
 
 namespace WebCore {
 
 PassRefPtr<IDBRequest> IDBRequest::create(ScriptExecutionContext* context, PassRefPtr<IDBAny> source, IDBTransaction* transaction)
 {
     RefPtr<IDBRequest> request(adoptRef(new IDBRequest(context, source, IDBTransactionBackendInterface::NormalTask, transaction)));
     request->suspendIfNeeded();
     return request.release();
 }
 
@@ skipping 14 matching lines @@
     , m_requestAborted(false)
     , m_source(source)
     , m_taskType(taskType)
     , m_hasPendingActivity(true)
     , m_cursorType(IDBCursorBackendInterface::InvalidCursorType)
     , m_cursorDirection(IDBCursor::NEXT)
     , m_cursorFinished(false)
     , m_pendingCursor(0)
     , m_didFireUpgradeNeededEvent(false)
     , m_preventPropagation(false)
+#if USE(V8)
+    , m_worldContextHandle(UseCurrentWorld)
+#endif
 {
     if (m_transaction) {
         m_transaction->registerRequest(this);
     }
 }
 
 IDBRequest::~IDBRequest()
 {
     ASSERT(m_readyState == DONE || m_readyState == EarlyDeath || !scriptExecutionContext());
 }
@@ skipping 188 matching lines @@
     m_result = IDBAny::create(domStringList);
     enqueueEvent(createSuccessEvent());
 }
 
 void IDBRequest::onSuccess(PassRefPtr<IDBCursorBackendInterface> backend, PassRefPtr<IDBKey> key, PassRefPtr<IDBKey> primaryKey, PassRefPtr<SerializedScriptValue> serializedValue)
 {
     IDB_TRACE("IDBRequest::onSuccess(IDBCursor)");
     if (!shouldEnqueueEvent())
         return;
 
+#if USE(V8)
+    v8::HandleScope handleScope;
+    v8::Local<v8::Context> context = toV8Context(scriptExecutionContext(), m_worldContextHandle);
+    if (context.IsEmpty())
+        CRASH();
+    v8::Context::Scope contextScope(context);
+#endif
+
     ScriptValue value = deserializeIDBValue(scriptExecutionContext(), serializedValue);
     ASSERT(m_cursorType != IDBCursorBackendInterface::InvalidCursorType);
     RefPtr<IDBCursor> cursor;
     if (m_cursorType == IDBCursorBackendInterface::IndexKeyCursor)
         cursor = IDBCursor::create(backend, m_cursorDirection, this, m_source.get(), m_transaction.get());
     else
         cursor = IDBCursorWithValue::create(backend, m_cursorDirection, this, m_source.get(), m_transaction.get());
     setResultCursor(cursor, key, primaryKey, value);
 
     enqueueEvent(createSuccessEvent());
@@ skipping 36 matching lines @@
     m_result = IDBAny::create(frontend.release());
     enqueueEvent(createSuccessEvent());
 }
 
 void IDBRequest::onSuccess(PassRefPtr<SerializedScriptValue> serializedScriptValue)
 {
     IDB_TRACE("IDBRequest::onSuccess(SerializedScriptValue)");
     if (!shouldEnqueueEvent())
         return;
 
+#if USE(V8)
+    v8::HandleScope handleScope;
+    v8::Local<v8::Context> context = toV8Context(scriptExecutionContext(), m_worldContextHandle);
+    if (context.IsEmpty())
+        CRASH();
+    v8::Context::Scope contextScope(context);
+#endif
+
     ScriptValue value = deserializeIDBValue(scriptExecutionContext(), serializedScriptValue);
     onSuccessInternal(value);
 }
 
 #ifndef NDEBUG
 static PassRefPtr<IDBObjectStore> effectiveObjectStore(PassRefPtr<IDBAny> source)
 {
     if (source->type() == IDBAny::IDBObjectStoreType)
         return source->idbObjectStore();
     if (source->type() == IDBAny::IDBIndexType)
         return source->idbIndex()->objectStore();
 
     ASSERT_NOT_REACHED();
     return 0;
 }
 #endif
 
 void IDBRequest::onSuccess(PassRefPtr<SerializedScriptValue> prpSerializedScriptValue, PassRefPtr<IDBKey> prpPrimaryKey, const IDBKeyPath& keyPath)
 {
     IDB_TRACE("IDBRequest::onSuccess(SerializedScriptValue, IDBKey, IDBKeyPath)");
     if (!shouldEnqueueEvent())
         return;
 
+#if USE(V8)
+    v8::HandleScope handleScope;
+    v8::Local<v8::Context> context = toV8Context(scriptExecutionContext(), m_worldContextHandle);
+    if (context.IsEmpty())
+        CRASH();
+    v8::Context::Scope contextScope(context);
+#endif
+
 #ifndef NDEBUG
     ASSERT(keyPath == effectiveObjectStore(m_source)->keyPath());
 #endif
     ScriptValue value = deserializeIDBValue(scriptExecutionContext(), prpSerializedScriptValue);
 
     RefPtr<IDBKey> primaryKey = prpPrimaryKey;
 #ifndef NDEBUG
     RefPtr<IDBKey> expectedKey = createIDBKeyFromScriptValueAndKeyPath(value, keyPath);
     ASSERT(!expectedKey || expectedKey->isEqual(primaryKey.get()));
 #endif
@@ skipping 21 matching lines @@
     }
     enqueueEvent(createSuccessEvent());
 }
 
 void IDBRequest::onSuccess(PassRefPtr<IDBKey> key, PassRefPtr<IDBKey> primaryKey, PassRefPtr<SerializedScriptValue> serializedValue)
 {
     IDB_TRACE("IDBRequest::onSuccess(key, primaryKey, value)");
     if (!shouldEnqueueEvent())
         return;
 
+#if USE(V8)
+    v8::HandleScope handleScope;
+    v8::Local<v8::Context> context = toV8Context(scriptExecutionContext(), m_worldContextHandle);
+    if (context.IsEmpty())
+        CRASH();
+    v8::Context::Scope contextScope(context);
+#endif
+
     ScriptValue value = deserializeIDBValue(scriptExecutionContext(), serializedValue);
     ASSERT(m_pendingCursor);
     setResultCursor(m_pendingCursor.release(), key, primaryKey, value);
     enqueueEvent(createSuccessEvent());
 }
 
 bool IDBRequest::hasPendingActivity() const
 {
     // FIXME: In an ideal world, we should return true as long as anyone has a or can
     //        get a handle to us and we have event listeners. This is order to handle
@@ skipping 25 matching lines @@
 bool IDBRequest::dispatchEvent(PassRefPtr<Event> event)
 {
     IDB_TRACE("IDBRequest::dispatchEvent");
     ASSERT(m_readyState == PENDING);
     ASSERT(!m_contextStopped);
     ASSERT(m_hasPendingActivity);
     ASSERT(m_enqueuedEvents.size());
     ASSERT(scriptExecutionContext());
     ASSERT(event->target() == this);
     ASSERT_WITH_MESSAGE(m_readyState < DONE, "When dispatching event %s, m_readyState < DONE(%d), was %d", event->type().string().utf8().data(), DONE, m_readyState);
+
+#if USE(V8)
+    v8::HandleScope handleScope;
+    v8::Local<v8::Context> context = toV8Context(scriptExecutionContext(), m_worldContextHandle);
+    if (context.IsEmpty())
+        CRASH();
+    v8::Context::Scope contextScope(context);
+#endif
+
     if (event->type() != eventNames().blockedEvent)
         m_readyState = DONE;
 
     for (size_t i = 0; i < m_enqueuedEvents.size(); ++i) {
         if (m_enqueuedEvents[i].get() == event.get())
             m_enqueuedEvents.remove(i);
     }
 
     Vector<RefPtr<EventTarget> > targets;
     targets.append(this);
@@ skipping 96 matching lines @@
 }
 
 EventTargetData* IDBRequest::ensureEventTargetData()
 {
     return &m_eventTargetData;
 }
 
 } // namespace WebCore
 
 #endif