Changeset 80183 in webkit


Ignore:
Timestamp:
Mar 2, 2011 4:40:33 PM (13 years ago)
Author:
jorlow@chromium.org
Message:

2011-03-02 David Grogan <​dgrogan@chromium.org>

Reviewed by Jeremy Orlow.

IndexedDB: fire versionchange events when calling setVersion
​https://bugs.webkit.org/show_bug.cgi?id=55095

  • storage/indexeddb/set_version_queue-expected.txt:
  • storage/indexeddb/set_version_queue.html:

2011-03-02 David Grogan <​dgrogan@chromium.org>

Reviewed by Jeremy Orlow.

IndexedDB: fire versionchange events when calling setVersion
​https://bugs.webkit.org/show_bug.cgi?id=55095

  • dom/EventNames.h:
  • storage/IDBDatabase.cpp: (WebCore::IDBDatabase::setVersion): (WebCore::IDBDatabase::close): (WebCore::IDBDatabase::onVersionChange): (WebCore::IDBDatabase::open): (WebCore::IDBDatabase::enqueueEvent): (WebCore::IDBDatabase::dispatchEvent):
  • storage/IDBDatabase.h: (WebCore::IDBDatabase::dispatchEvent):
  • storage/IDBDatabase.idl:
  • storage/IDBDatabaseBackendImpl.cpp: (WebCore::IDBDatabaseBackendImpl::PendingSetVersionCall::create): (WebCore::IDBDatabaseBackendImpl::PendingSetVersionCall::databaseCallbacks): (WebCore::IDBDatabaseBackendImpl::PendingSetVersionCall::PendingSetVersionCall): (WebCore::IDBDatabaseBackendImpl::IDBDatabaseBackendImpl): (WebCore::IDBDatabaseBackendImpl::setVersion): (WebCore::IDBDatabaseBackendImpl::open): (WebCore::IDBDatabaseBackendImpl::close):
  • storage/IDBDatabaseBackendImpl.h:
  • storage/IDBDatabaseBackendInterface.h:
  • storage/IDBDatabaseCallbacks.h: Copied from Source/WebCore/storage/IDBVersionChangeEvent.cpp. (WebCore::IDBDatabaseCallbacks::~IDBDatabaseCallbacks):
  • storage/IDBFactoryBackendImpl.cpp: (WebCore::IDBFactoryBackendImpl::open):
  • storage/IDBRequest.cpp: (WebCore::IDBRequest::onSuccess):
  • storage/IDBVersionChangeEvent.cpp: (WebCore::IDBVersionChangeEvent::create): (WebCore::IDBVersionChangeEvent::IDBVersionChangeEvent):
  • storage/IDBVersionChangeEvent.h:
  • storage/IDBVersionChangeRequest.cpp: (WebCore::IDBVersionChangeRequest::onBlocked):

2011-03-02 David Grogan <​dgrogan@chromium.org>

Reviewed by Jeremy Orlow.

IndexedDB: fire versionchange events when calling setVersion
​https://bugs.webkit.org/show_bug.cgi?id=55095

  • WebKit.gyp:
  • src/IDBDatabaseCallbacksProxy.cpp: Copied from Source/WebCore/storage/IDBVersionChangeEvent.h. (WebCore::IDBDatabaseCallbacksProxy::create): (WebCore::IDBDatabaseCallbacksProxy::IDBDatabaseCallbacksProxy): (WebCore::IDBDatabaseCallbacksProxy::~IDBDatabaseCallbacksProxy): (WebCore::IDBDatabaseCallbacksProxy::onVersionChange):
  • src/IDBDatabaseCallbacksProxy.h: Copied from Source/WebCore/storage/IDBVersionChangeEvent.h.
  • src/IDBDatabaseProxy.cpp: (WebCore::IDBDatabaseProxy::setVersion): (WebCore::IDBDatabaseProxy::close): (WebCore::IDBDatabaseProxy::open):
  • src/IDBDatabaseProxy.h:
  • src/WebIDBDatabaseCallbacksImpl.cpp: Copied from Source/WebCore/storage/IDBVersionChangeEvent.cpp. (WebCore::WebIDBDatabaseCallbacksImpl::WebIDBDatabaseCallbacksImpl): (WebCore::WebIDBDatabaseCallbacksImpl::~WebIDBDatabaseCallbacksImpl): (WebCore::WebIDBDatabaseCallbacksImpl::onVersionChange):
  • src/WebIDBDatabaseCallbacksImpl.h: Copied from Source/WebCore/storage/IDBVersionChangeEvent.h.
  • src/WebIDBDatabaseImpl.cpp: (WebKit::WebIDBDatabaseImpl::setVersion): (WebKit::WebIDBDatabaseImpl::close): (WebKit::WebIDBDatabaseImpl::open):
  • src/WebIDBDatabaseImpl.h:
Location:
trunk
Files:
22 edited
5 copied

Legend:

Unmodified
Added
Removed

  • trunk/LayoutTests/ChangeLog

    r80181 r80183  
     12011-03-02  David Grogan  <dgrogan@chromium.org>
     2
     3        Reviewed by Jeremy Orlow.
     4
     5        IndexedDB: fire versionchange events when calling setVersion
     6        https://bugs.webkit.org/show_bug.cgi?id=55095
     7
     8        * storage/indexeddb/set_version_queue-expected.txt:
     9        * storage/indexeddb/set_version_queue.html:
     10
    1112011-03-02  Sheriff Bot  <webkit.review.bot@gmail.com>
    212

  • trunk/LayoutTests/storage/indexeddb/set_version_queue-expected.txt

    r79458 r80183  
    1 An open connection blocks a separate connection's setVersion call
     14 open connections try to setVersion at the same time. 3 connections eventually close, allowing 1 setVersion call to proceed.
    22
    33On success, you will see a series of "PASS" messages, followed by "TEST COMPLETE".
    … …  
    88IndexedDB.open('set-version-queue')
    99IndexedDB.open('set-version-queue')
    10 connections[0].setVersion('version 1')
    11 connections[1].setVersion('version 2')
    12 connections[2].setVersion('version 3')
     10IndexedDB.open('set-version-queue')
     11connections[0].setVersion('version 0')
     12connections[1].setVersion('version 1')
     13connections[2].setVersion('version 2')
     14connections[3].setVersion('version 3')
    1315
     16PASS event.version.length > 0 is true
     17connection[1] received versionChangeEvent: version 0
     18PASS event.version.length > 0 is true
     19connection[2] received versionChangeEvent: version 0
     20PASS event.version.length > 0 is true
     21connection[3] received versionChangeEvent: version 0
     22
     23PASS connection[0] got blocked event
     24PASS event.version is "version 0"
     25Close the connection that received the block event:
     26connections[0].close()
     27Close another connection as well, to test 4.7.4-note:
     28connections[3].close()
     29blocked0fired = true
     30
     31PASS event.version.length > 0 is true
     32connection[2] received versionChangeEvent: version 1
     33
     34PASS connection[1] got blocked event
     35Ensure that this blocked event is in order:
     36PASS blocked0fired is true
     37PASS blocked2fired is false
     38
     39PASS event.version.length > 0 is true
     40connection[1] received versionChangeEvent: version 2
     41
     42PASS connection[2] got blocked event
     43PASS event.version is "version 2"
    1444connections[2].close()
    15 PASS blocked1fired is true
    16 PASS blocked3fired is false
    17 connections[0].close()
    18 FIXME: The first setVersion shouldn't get fired
    19 PASS inSetVersion2
    20 FIXME: The third setVersion shouldn't get fired
     45blocked2fired = true
     46
     47PASS event.version.length > 0 is true
     48connection[1] received versionChangeEvent: version 3
     49
     50PASS connection[3] got blocked event
     51Note: This means that a connection can receive a blocked event after its close() method has been called.  Spec is silent on the issue and this is easiest to implement.
     52PASS event.version is "version 3"
     53
     54PASS connection[0] got error event
     55PASS event.target.errorCode is 13
     56PASS event.target.webkitErrorMessage.length > 0 is true
     57Connection was closed before set version transaction was created
     58
     59PASS connection[2] got error event
     60PASS event.target.errorCode is 13
     61PASS event.target.webkitErrorMessage.length > 0 is true
     62Connection was closed before set version transaction was created
     63
     64PASS connection[3] got error event
     65PASS event.target.errorCode is 13
     66PASS event.target.webkitErrorMessage.length > 0 is true
     67Connection was closed before set version transaction was created
     68
     69PASS connection[1] got into SetVersion
    2170PASS successfullyParsed is true
    2271

  • trunk/LayoutTests/storage/indexeddb/set_version_queue.html

    r79458 r80183  
    1111<script>
    1212
    13 description("An open connection blocks a separate connection's setVersion call");
     13description("4 open connections try to setVersion at the same time.  3 connections eventually close, allowing 1 setVersion call to proceed.");
    1414if (window.layoutTestController)
    1515    layoutTestController.waitUntilDone();
    … …  
    3636{
    3737    connection = event.target.result;
     38    connection.onversionchange = generateVersionChangeHandler();
    3839    connections.push(connection);
    39     if (connections.length < 3)
     40    if (connections.length < 4)
    4041        openDBConnection();
    4142    else {
    42         result = evalAndLog("connections[0].setVersion('version 1')");
    43         result.onerror = unexpectedErrorCallback;
    44         result.onsuccess = inSetVersion;
    45         result.onblocked = blocked1;
    46         result2 = evalAndLog("connections[1].setVersion('version 2')");
    47         result2.onerror = unexpectedErrorCallback;
    48         result2.onsuccess = inSetVersion2;
    49         result2.onblocked = blocked2;
    50         result3 = evalAndLog("connections[2].setVersion('version 3')");
    51         result3.onerror = unexpectedErrorCallback;
    52         result3.onsuccess = inSetVersion3;
    53         result3.onblocked = blocked3;
     43        request = evalAndLog("connections[0].setVersion('version 0')");
     44        request.onerror = function(event){ connectionError(event, 0) };
     45        request.onsuccess = unexpectedSuccessCallback;
     46        request.onblocked = blocked0;
     47        request1 = evalAndLog("connections[1].setVersion('version 1')");
     48        request1.onerror = unexpectedErrorCallback;
     49        request1.onsuccess = inSetVersion1;
     50        request1.onblocked = blocked1;
     51        request2 = evalAndLog("connections[2].setVersion('version 2')");
     52        request2.onerror = function(event){ connectionError(event, 2) };
     53        request2.onsuccess = unexpectedSuccessCallback;
     54        request2.onblocked = blocked2;
     55        request3 = evalAndLog("connections[3].setVersion('version 3')");
     56        request3.onerror = function(event){ connectionError(event, 3) };
     57        request3.onsuccess = unexpectedSuccessCallback;
     58        request3.onblocked = blocked3;
    5459        debug("");
    5560    }
    5661}
    5762
    58 blocked1fired = false;
    59 blocked3fired = false;
    60 function blocked1()
     63function generateVersionChangeHandler()
    6164{
    62     evalAndLog("connections[2].close()");
    63     blocked1fired = true;
     65    var connectionNum = connections.length;
     66    return function(event)
     67    {
     68        shouldBeTrue("event.version.length > 0");
     69        debug("connection[" + connectionNum + "] received versionChangeEvent: " + event.version);
     70    }
    6471}
    6572
    66 function blocked2()
     73blocked0fired = false;
     74blocked2fired = false;
     75function blocked0(event)
    6776{
    68     shouldBeTrue("blocked1fired");
    69     shouldBeFalse("blocked3fired");
     77    debug("");
     78    testPassed("connection[0] got blocked event");
     79    shouldBeEqualToString("event.version", "version 0");
     80    debug("Close the connection that received the block event:");
     81    evalAndLog("connections[0].close()");
     82    debug("Close another connection as well, to test 4.7.4-note:");
     83    evalAndLog("connections[3].close()");
     84    evalAndLog("blocked0fired = true");
     85    debug("");
    7086}
    7187
    72 function blocked3()
     88function blocked1(event)
    7389{
    74     evalAndLog("connections[0].close()");
    75     blocked3fired = true;
     90    debug("")
     91    testPassed("connection[1] got blocked event");
     92    debug("Ensure that this blocked event is in order:");
     93    shouldBeTrue("blocked0fired");
     94    shouldBeFalse("blocked2fired");
     95    debug("")
    7696}
    7797
    78 function inSetVersion()
     98function blocked2(event)
    7999{
    80     debug("FIXME: The first setVersion shouldn't get fired");
     100    debug("")
     101    testPassed("connection[2] got blocked event");
     102    shouldBeEqualToString("event.version", "version 2");
     103    evalAndLog("connections[2].close()");
     104    evalAndLog("blocked2fired = true");
     105    debug("")
    81106}
    82107
    83 function inSetVersion2()
     108function blocked3(event)
    84109{
    85     testPassed("inSetVersion2");
     110    debug("")
     111    testPassed("connection[3] got blocked event");
     112    debug("Note: This means that a connection can receive a blocked event after its close() method has been called.  Spec is silent on the issue and this is easiest to implement.");
     113    shouldBeEqualToString("event.version", "version 3");
    86114}
    87115
    88 function inSetVersion3()
     116function connectionError(event, connectionId)
    89117{
    90     debug("FIXME: The third setVersion shouldn't get fired");
     118    debug("")
     119    testPassed("connection[" + connectionId + "] got error event");
     120    shouldBe("event.target.errorCode", "13")
     121    if ('webkitIndexedDB' in window) {
     122        shouldBe("event.target.webkitErrorMessage.length > 0", "true");
     123        debug(event.target.webkitErrorMessage);
     124    }
     125}
     126
     127function inSetVersion1(event)
     128{
     129    debug("")
     130    testPassed("connection[1] got into SetVersion");
    91131    done();
    92132}

  • trunk/Source/WebCore/ChangeLog

    r80182 r80183  
     12011-03-02  David Grogan  <dgrogan@chromium.org>
     2
     3        Reviewed by Jeremy Orlow.
     4
     5        IndexedDB: fire versionchange events when calling setVersion
     6        https://bugs.webkit.org/show_bug.cgi?id=55095
     7
     8        * dom/EventNames.h:
     9        * storage/IDBDatabase.cpp:
     10        (WebCore::IDBDatabase::setVersion):
     11        (WebCore::IDBDatabase::close):
     12        (WebCore::IDBDatabase::onVersionChange):
     13        (WebCore::IDBDatabase::open):
     14        (WebCore::IDBDatabase::enqueueEvent):
     15        (WebCore::IDBDatabase::dispatchEvent):
     16        * storage/IDBDatabase.h:
     17        (WebCore::IDBDatabase::dispatchEvent):
     18        * storage/IDBDatabase.idl:
     19        * storage/IDBDatabaseBackendImpl.cpp:
     20        (WebCore::IDBDatabaseBackendImpl::PendingSetVersionCall::create):
     21        (WebCore::IDBDatabaseBackendImpl::PendingSetVersionCall::databaseCallbacks):
     22        (WebCore::IDBDatabaseBackendImpl::PendingSetVersionCall::PendingSetVersionCall):
     23        (WebCore::IDBDatabaseBackendImpl::IDBDatabaseBackendImpl):
     24        (WebCore::IDBDatabaseBackendImpl::setVersion):
     25        (WebCore::IDBDatabaseBackendImpl::open):
     26        (WebCore::IDBDatabaseBackendImpl::close):
     27        * storage/IDBDatabaseBackendImpl.h:
     28        * storage/IDBDatabaseBackendInterface.h:
     29        * storage/IDBDatabaseCallbacks.h: Copied from Source/WebCore/storage/IDBVersionChangeEvent.cpp.
     30        (WebCore::IDBDatabaseCallbacks::~IDBDatabaseCallbacks):
     31        * storage/IDBFactoryBackendImpl.cpp:
     32        (WebCore::IDBFactoryBackendImpl::open):
     33        * storage/IDBRequest.cpp:
     34        (WebCore::IDBRequest::onSuccess):
     35        * storage/IDBVersionChangeEvent.cpp:
     36        (WebCore::IDBVersionChangeEvent::create):
     37        (WebCore::IDBVersionChangeEvent::IDBVersionChangeEvent):
     38        * storage/IDBVersionChangeEvent.h:
     39        * storage/IDBVersionChangeRequest.cpp:
     40        (WebCore::IDBVersionChangeRequest::onBlocked):
     41
    1422011-03-02  Alexey Proskuryakov  <ap@apple.com>
    243

  • trunk/Source/WebCore/dom/EventNames.h

    r79208 r80183  
    108108    macro(unload) \
    109109    macro(updateready) \
     110    macro(versionchange) \
    110111    macro(write) \
    111112    macro(writeend) \

  • trunk/Source/WebCore/storage/IDBDatabase.cpp

    r78752 r80183  
    2727#include "IDBDatabase.h"
    2828
     29#include "Document.h"
     30#include "EventQueue.h"
    2931#include "IDBAny.h"
    3032#include "IDBDatabaseError.h"
    3133#include "IDBDatabaseException.h"
     34#include "IDBEventDispatcher.h"
    3235#include "IDBFactoryBackendInterface.h"
    3336#include "IDBIndex.h"
    3437#include "IDBObjectStore.h"
     38#include "IDBVersionChangeEvent.h"
    3539#include "IDBVersionChangeRequest.h"
    3640#include "IDBTransaction.h"
    … …  
    100104{
    101105    RefPtr<IDBVersionChangeRequest> request = IDBVersionChangeRequest::create(context, IDBAny::create(this), version);
    102     m_backend->setVersion(version, request, ec);
     106    m_backend->setVersion(version, request, this, ec);
    103107    return request;
    104108}
    … …  
    138142    if (m_noNewTransactions)
    139143        return;
     144
     145    ASSERT(scriptExecutionContext()->isDocument());
     146    EventQueue* eventQueue = static_cast<Document*>(scriptExecutionContext())->eventQueue();
     147    // Remove any pending versionchange events scheduled to fire on this
     148    // connection. They would have been scheduled by the backend when another
     149    // connection called setVersion, but the frontend connection is being
     150    // closed before they could fire.
     151    for (size_t i = 0; i < m_enqueuedEvents.size(); ++i) {
     152        bool removed = eventQueue->cancelEvent(m_enqueuedEvents[i].get());
     153        ASSERT_UNUSED(removed, removed);
     154    }
     155
    140156    m_noNewTransactions = true;
    141     m_backend->close();
     157    m_backend->close(this);
     158}
     159
     160void IDBDatabase::onVersionChange(const String& version)
     161{
     162    enqueueEvent(IDBVersionChangeEvent::create(version, eventNames().versionchangeEvent));
    142163}
    143164
    … …  
    152173}
    153174
     175void IDBDatabase::open()
     176{
     177    m_backend->open(this);
     178}
     179
     180void IDBDatabase::enqueueEvent(PassRefPtr<Event> event)
     181{
     182    ASSERT(scriptExecutionContext()->isDocument());
     183    EventQueue* eventQueue = static_cast<Document*>(scriptExecutionContext())->eventQueue();
     184    event->setTarget(this);
     185    eventQueue->enqueueEvent(event.get());
     186    m_enqueuedEvents.append(event);
     187}
     188
     189bool IDBDatabase::dispatchEvent(PassRefPtr<Event> event)
     190{
     191    ASSERT(event->type() == eventNames().versionchangeEvent);
     192    for (size_t i = 0; i < m_enqueuedEvents.size(); ++i) {
     193        if (m_enqueuedEvents[i].get() == event.get())
     194            m_enqueuedEvents.remove(i);
     195    }
     196    return EventTarget::dispatchEvent(event.get());
     197}
     198
    154199void IDBDatabase::stop()
    155200{

  • trunk/Source/WebCore/storage/IDBDatabase.h

    r78752 r80183  
    3333#include "ExceptionCode.h"
    3434#include "IDBDatabaseBackendInterface.h"
     35#include "IDBDatabaseCallbacks.h"
    3536#include "IDBObjectStore.h"
    3637#include "IDBTransaction.h"
    … …  
    4748class ScriptExecutionContext;
    4849
    49 class IDBDatabase : public RefCounted<IDBDatabase>, public EventTarget, public ActiveDOMObject {
     50class IDBDatabase : public IDBDatabaseCallbacks, public EventTarget, public ActiveDOMObject {
    5051public:
    5152    static PassRefPtr<IDBDatabase> create(ScriptExecutionContext*, PassRefPtr<IDBDatabaseBackendInterface>);
    … …  
    7273    DEFINE_ATTRIBUTE_EVENT_LISTENER(abort);
    7374    DEFINE_ATTRIBUTE_EVENT_LISTENER(error);
     75    DEFINE_ATTRIBUTE_EVENT_LISTENER(versionchange);
     76
     77    // IDBDatabaseCallbacks
     78    virtual void onVersionChange(const String& requestedVersion);
    7479
    7580    // ActiveDOMObject
    … …  
    8186    virtual ScriptExecutionContext* scriptExecutionContext() const;
    8287
    83     using RefCounted<IDBDatabase>::ref;
    84     using RefCounted<IDBDatabase>::deref;
     88
     89    void open();
     90    void enqueueEvent(PassRefPtr<Event>);
     91    bool dispatchEvent(PassRefPtr<Event> event, ExceptionCode& ec) { return EventTarget::dispatchEvent(event, ec); }
     92    virtual bool dispatchEvent(PassRefPtr<Event>);
     93
     94    using RefCounted<IDBDatabaseCallbacks>::ref;
     95    using RefCounted<IDBDatabaseCallbacks>::deref;
    8596
    8697private:
    … …  
    100111
    101112    EventTargetData m_eventTargetData;
     113
     114    // Keep track of the versionchange events waiting to be fired on this
     115    // database so that we can cancel them if the database closes.
     116    Vector<RefPtr<Event> > m_enqueuedEvents;
    102117};
    103118

  • trunk/Source/WebCore/storage/IDBDatabase.idl

    r78752 r80183  
    3636        attribute EventListener onabort;
    3737        attribute EventListener onerror;
     38        attribute EventListener onversionchange;
    3839
    3940        IDBObjectStore createObjectStore(in DOMString name, in [Optional] OptionsObject options)
    … …  
    5455                                 in EventListener listener,
    5556                                 in boolean useCapture);
    56         boolean dispatchEvent(in Event evt) 
     57        boolean dispatchEvent(in Event evt)
    5758            raises(EventException);
    5859    };

  • trunk/Source/WebCore/storage/IDBDatabaseBackendImpl.cpp

    r79445 r80183  
    4242class IDBDatabaseBackendImpl::PendingSetVersionCall : public RefCounted<PendingSetVersionCall> {
    4343public:
    44     static PassRefPtr<PendingSetVersionCall> create(const String& version, PassRefPtr<IDBCallbacks> callbacks)
     44    static PassRefPtr<PendingSetVersionCall> create(const String& version, PassRefPtr<IDBCallbacks> callbacks, PassRefPtr<IDBDatabaseCallbacks> databaseCallbacks)
    4545    {
    46         return adoptRef(new PendingSetVersionCall(version, callbacks));
     46        return adoptRef(new PendingSetVersionCall(version, callbacks, databaseCallbacks));
    4747    }
    4848    String version() { return m_version; }
    4949    PassRefPtr<IDBCallbacks> callbacks() { return m_callbacks; }
     50    PassRefPtr<IDBDatabaseCallbacks> databaseCallbacks() { return m_databaseCallbacks; }
     51
    5052private:
    51     PendingSetVersionCall(const String& version, PassRefPtr<IDBCallbacks> callbacks)
     53    PendingSetVersionCall(const String& version, PassRefPtr<IDBCallbacks> callbacks, PassRefPtr<IDBDatabaseCallbacks> databaseCallbacks)
    5254        : m_version(version)
    5355        , m_callbacks(callbacks)
     56        , m_databaseCallbacks(databaseCallbacks)
    5457    {
    5558    }
    5659    String m_version;
    5760    RefPtr<IDBCallbacks> m_callbacks;
     61    RefPtr<IDBDatabaseCallbacks> m_databaseCallbacks;
    5862};
    5963
    … …  
    6670    , m_factory(factory)
    6771    , m_transactionCoordinator(coordinator)
    68     , m_openConnectionCount(0)
    6972{
    7073    ASSERT(!m_name.isNull());
    … …  
    160163}
    161164
    162 void IDBDatabaseBackendImpl::setVersion(const String& version, PassRefPtr<IDBCallbacks> prpCallbacks, ExceptionCode& ec)
    163 {
     165void IDBDatabaseBackendImpl::setVersion(const String& version, PassRefPtr<IDBCallbacks> prpCallbacks, PassRefPtr<IDBDatabaseCallbacks> prpDatabaseCallbacks, ExceptionCode& ec)
     166{
     167    RefPtr<IDBCallbacks> callbacks = prpCallbacks;
     168    RefPtr<IDBDatabaseCallbacks> databaseCallbacks = prpDatabaseCallbacks;
     169    if (!m_databaseCallbacksSet.contains(databaseCallbacks)) {
     170        callbacks->onError(IDBDatabaseError::create(IDBDatabaseException::ABORT_ERR, "Connection was closed before set version transaction was created"));
     171        return;
     172    }
     173    for (DatabaseCallbacksSet::const_iterator it = m_databaseCallbacksSet.begin(); it != m_databaseCallbacksSet.end(); ++it) {
     174        if (*it != databaseCallbacks)
     175            (*it)->onVersionChange(version);
     176    }
     177    if (m_databaseCallbacksSet.size() > 1) {
     178        callbacks->onBlocked();
     179        RefPtr<PendingSetVersionCall> pendingSetVersionCall = PendingSetVersionCall::create(version, callbacks, databaseCallbacks);
     180        m_pendingSetVersionCalls.append(pendingSetVersionCall);
     181        return;
     182    }
     183
     184    RefPtr<DOMStringList> objectStoreNames = DOMStringList::create();
    164185    RefPtr<IDBDatabaseBackendImpl> database = this;
    165     RefPtr<IDBCallbacks> callbacks = prpCallbacks;
    166 
    167     // FIXME: Only continue if the connection is still open.
    168     if (m_openConnectionCount > 1) {
    169         callbacks->onBlocked();
    170         RefPtr<PendingSetVersionCall> pendingSetVersionCall = PendingSetVersionCall::create(version, callbacks);
    171         m_pendingSetVersionCalls.append(pendingSetVersionCall);
    172         return;
    173     }
    174 
    175     RefPtr<DOMStringList> objectStoreNames = DOMStringList::create();
    176186    RefPtr<IDBTransactionBackendInterface> transaction = IDBTransactionBackendImpl::create(objectStoreNames.get(), IDBTransaction::VERSION_CHANGE, this);
    177187    if (!transaction->scheduleTask(createCallbackTask(&IDBDatabaseBackendImpl::setVersionInternal, database, version, callbacks, transaction),
    … …  
    207217}
    208218
    209 void IDBDatabaseBackendImpl::open()
    210 {
    211     m_openConnectionCount++;
    212 }
    213 
    214 void IDBDatabaseBackendImpl::close()
    215 {
    216     m_openConnectionCount--;
    217     ASSERT(m_openConnectionCount >= 0);
    218     if (m_openConnectionCount > 1)
     219void IDBDatabaseBackendImpl::open(PassRefPtr<IDBDatabaseCallbacks> callbacks)
     220{
     221    m_databaseCallbacksSet.add(RefPtr<IDBDatabaseCallbacks>(callbacks));
     222}
     223
     224void IDBDatabaseBackendImpl::close(PassRefPtr<IDBDatabaseCallbacks> prpCallbacks)
     225{
     226    RefPtr<IDBDatabaseCallbacks> callbacks = prpCallbacks;
     227    ASSERT(m_databaseCallbacksSet.contains(callbacks));
     228    m_databaseCallbacksSet.remove(callbacks);
     229    if (m_databaseCallbacksSet.size() > 1)
    219230        return;
    220231
    … …  
    222233        ExceptionCode ec = 0;
    223234        RefPtr<PendingSetVersionCall> pendingSetVersionCall = m_pendingSetVersionCalls.takeFirst();
    224         setVersion(pendingSetVersionCall->version(), pendingSetVersionCall->callbacks(), ec);
     235        setVersion(pendingSetVersionCall->version(), pendingSetVersionCall->callbacks(), pendingSetVersionCall->databaseCallbacks(), ec);
    225236        ASSERT(!ec);
    226237    }

  • trunk/Source/WebCore/storage/IDBDatabaseBackendImpl.h

    r79426 r80183  
    3131#include <wtf/Deque.h>
    3232#include <wtf/HashMap.h>
    33 #include <wtf/text/StringHash.h>
     33#include <wtf/ListHashSet.h>
    3434
    3535#if ENABLE(INDEXED_DATABASE)
    … …  
    3838
    3939class IDBBackingStore;
     40class IDBDatabase;
    4041class IDBFactoryBackendImpl;
    4142class IDBObjectStoreBackendImpl;
    … …  
    5556    static const int64_t InvalidId = 0;
    5657    int64_t id() const { return m_id; }
    57     void open();
     58    void open(PassRefPtr<IDBDatabaseCallbacks>);
    5859
    5960    virtual String name() const { return m_name; }
    … …  
    6364    virtual PassRefPtr<IDBObjectStoreBackendInterface> createObjectStore(const String& name, const String& keyPath, bool autoIncrement, IDBTransactionBackendInterface*, ExceptionCode&);
    6465    virtual void deleteObjectStore(const String& name, IDBTransactionBackendInterface*, ExceptionCode&);
    65     virtual void setVersion(const String& version, PassRefPtr<IDBCallbacks>, ExceptionCode&);
     66    virtual void setVersion(const String& version, PassRefPtr<IDBCallbacks>, PassRefPtr<IDBDatabaseCallbacks>, ExceptionCode&);
    6667    virtual PassRefPtr<IDBTransactionBackendInterface> transaction(DOMStringList* objectStoreNames, unsigned short mode, ExceptionCode&);
    67     virtual void close();
     68    virtual void close(PassRefPtr<IDBDatabaseCallbacks>);
    6869
    6970    PassRefPtr<IDBObjectStoreBackendInterface> objectStore(const String& name);
    … …  
    9899    RefPtr<IDBTransactionCoordinator> m_transactionCoordinator;
    99100
    100     int m_openConnectionCount;
    101 
    102101    class PendingSetVersionCall;
    103102    Deque<RefPtr<PendingSetVersionCall> > m_pendingSetVersionCalls;
     103
     104    typedef ListHashSet<RefPtr<IDBDatabaseCallbacks> > DatabaseCallbacksSet;
     105    DatabaseCallbacksSet m_databaseCallbacksSet;
    104106};
    105107

  • trunk/Source/WebCore/storage/IDBDatabaseBackendInterface.h

    r78752 r80183  
    3939class Frame;
    4040class IDBCallbacks;
     41class IDBDatabaseCallbacks;
    4142class IDBObjectStoreBackendInterface;
    4243class IDBTransactionBackendInterface;
    … …  
    5657    virtual PassRefPtr<IDBObjectStoreBackendInterface> createObjectStore(const String& name, const String& keyPath, bool autoIncrement, IDBTransactionBackendInterface*, ExceptionCode&) = 0;
    5758    virtual void deleteObjectStore(const String& name, IDBTransactionBackendInterface*, ExceptionCode&) = 0;
    58     virtual void setVersion(const String& version, PassRefPtr<IDBCallbacks>, ExceptionCode&) = 0;
     59    virtual void setVersion(const String& version, PassRefPtr<IDBCallbacks>, PassRefPtr<IDBDatabaseCallbacks>, ExceptionCode&) = 0;
    5960    virtual PassRefPtr<IDBTransactionBackendInterface> transaction(DOMStringList* storeNames, unsigned short mode, ExceptionCode&) = 0;
    60     virtual void close() = 0;
     61    virtual void close(PassRefPtr<IDBDatabaseCallbacks>) = 0;
     62
     63    virtual void open(PassRefPtr<IDBDatabaseCallbacks>) = 0;
    6164};
    6265

  • trunk/Source/WebCore/storage/IDBDatabaseCallbacks.h

    r80182 r80183  
    2424 */
    2525
    26 #include "config.h"
    27 #include "IDBVersionChangeEvent.h"
     26#ifndef IDBDatabaseCallbacks_h
     27#define IDBDatabaseCallbacks_h
    2828
    2929#if ENABLE(INDEXED_DATABASE)
    3030
    31 #include "EventNames.h"
    32 #include "IDBAny.h"
     31#include "PlatformString.h"
     32#include <wtf/RefCounted.h>
    3333
    3434namespace WebCore {
    3535
    36 PassRefPtr<IDBVersionChangeEvent> IDBVersionChangeEvent::create(const String& version)
    37 {
    38     return adoptRef(new IDBVersionChangeEvent(version));
    39 }
     36class IDBDatabaseCallbacks : public RefCounted<IDBDatabaseCallbacks> {
     37public:
     38    virtual ~IDBDatabaseCallbacks() { }
    4039
    41 IDBVersionChangeEvent::IDBVersionChangeEvent(const String& version)
    42     : Event(eventNames().blockedEvent, false /*canBubble*/, false /*cancelable*/)
    43     , m_version(version)
    44 {
    45 }
    46 
    47 IDBVersionChangeEvent::~IDBVersionChangeEvent()
    48 {
    49 }
    50 
    51 String IDBVersionChangeEvent::version()
    52 {
    53     return m_version;
    54 }
     40    virtual void onVersionChange(const String& version) = 0;
     41};
    5542
    5643} // namespace WebCore
    5744
    5845#endif
     46
     47#endif // IDBDatabaseCallbacks_h

  • trunk/Source/WebCore/storage/IDBFactoryBackendImpl.cpp

    r79445 r80183  
    7676    IDBDatabaseBackendMap::iterator it = m_databaseBackendMap.find(uniqueIdentifier);
    7777    if (it != m_databaseBackendMap.end()) {
    78         it->second->open();
    7978        callbacks->onSuccess(it->second);
    8079        return;
    … …  
    9695
    9796    RefPtr<IDBDatabaseBackendImpl> databaseBackend = IDBDatabaseBackendImpl::create(name, backingStore.get(), m_transactionCoordinator.get(), this, uniqueIdentifier);
    98     databaseBackend->open();
    9997    callbacks->onSuccess(databaseBackend.get());
    10098    m_databaseBackendMap.set(uniqueIdentifier, databaseBackend.get());

  • trunk/Source/WebCore/storage/IDBRequest.cpp

    r80171 r80183  
    200200{
    201201    ASSERT(!m_errorCode && m_errorMessage.isNull() && !m_result);
    202     m_result = IDBAny::create(IDBDatabase::create(scriptExecutionContext(), backend));
     202    RefPtr<IDBDatabase> idbDatabase = IDBDatabase::create(scriptExecutionContext(), backend);
     203    idbDatabase->open();
     204
     205    m_result = IDBAny::create(idbDatabase.release());
    203206    enqueueEvent(createSuccessEvent());
    204207}

  • trunk/Source/WebCore/storage/IDBVersionChangeEvent.cpp

    r78752 r80183  
    3434namespace WebCore {
    3535
    36 PassRefPtr<IDBVersionChangeEvent> IDBVersionChangeEvent::create(const String& version)
     36PassRefPtr<IDBVersionChangeEvent> IDBVersionChangeEvent::create(const String& version, const AtomicString& eventType)
    3737{
    38     return adoptRef(new IDBVersionChangeEvent(version));
     38    return adoptRef(new IDBVersionChangeEvent(version, eventType));
    3939}
    4040
    41 IDBVersionChangeEvent::IDBVersionChangeEvent(const String& version)
    42     : Event(eventNames().blockedEvent, false /*canBubble*/, false /*cancelable*/)
     41IDBVersionChangeEvent::IDBVersionChangeEvent(const String& version, const AtomicString& eventType)
     42    : Event(eventType, false /*canBubble*/, false /*cancelable*/)
    4343    , m_version(version)
    4444{

  • trunk/Source/WebCore/storage/IDBVersionChangeEvent.h

    r78752 r80183  
    4040class IDBVersionChangeEvent : public Event {
    4141public:
    42     static PassRefPtr<IDBVersionChangeEvent> create(const String& version);
     42    static PassRefPtr<IDBVersionChangeEvent> create(const String& version, const AtomicString& eventType);
    4343    // FIXME: Need to allow creation of these events from JS.
    4444    virtual ~IDBVersionChangeEvent();
    … …  
    4949
    5050private:
    51     IDBVersionChangeEvent(const String& version);
     51    IDBVersionChangeEvent(const String& version, const AtomicString& eventType);
    5252
    5353    String m_version;

  • trunk/Source/WebCore/storage/IDBVersionChangeRequest.cpp

    r78752 r80183  
    5252{
    5353    ASSERT(!m_errorCode && m_errorMessage.isNull() && !m_result);
    54     enqueueEvent(IDBVersionChangeEvent::create(m_version));
     54    enqueueEvent(IDBVersionChangeEvent::create(m_version, eventNames().blockedEvent));
    5555}
    5656

  • trunk/Source/WebKit/chromium/ChangeLog

    r80181 r80183  
     12011-03-02  David Grogan  <dgrogan@chromium.org>
     2
     3        Reviewed by Jeremy Orlow.
     4
     5        IndexedDB: fire versionchange events when calling setVersion
     6        https://bugs.webkit.org/show_bug.cgi?id=55095
     7
     8        * WebKit.gyp:
     9        * src/IDBDatabaseCallbacksProxy.cpp: Copied from Source/WebCore/storage/IDBVersionChangeEvent.h.
     10        (WebCore::IDBDatabaseCallbacksProxy::create):
     11        (WebCore::IDBDatabaseCallbacksProxy::IDBDatabaseCallbacksProxy):
     12        (WebCore::IDBDatabaseCallbacksProxy::~IDBDatabaseCallbacksProxy):
     13        (WebCore::IDBDatabaseCallbacksProxy::onVersionChange):
     14        * src/IDBDatabaseCallbacksProxy.h: Copied from Source/WebCore/storage/IDBVersionChangeEvent.h.
     15        * src/IDBDatabaseProxy.cpp:
     16        (WebCore::IDBDatabaseProxy::setVersion):
     17        (WebCore::IDBDatabaseProxy::close):
     18        (WebCore::IDBDatabaseProxy::open):
     19        * src/IDBDatabaseProxy.h:
     20        * src/WebIDBDatabaseCallbacksImpl.cpp: Copied from Source/WebCore/storage/IDBVersionChangeEvent.cpp.
     21        (WebCore::WebIDBDatabaseCallbacksImpl::WebIDBDatabaseCallbacksImpl):
     22        (WebCore::WebIDBDatabaseCallbacksImpl::~WebIDBDatabaseCallbacksImpl):
     23        (WebCore::WebIDBDatabaseCallbacksImpl::onVersionChange):
     24        * src/WebIDBDatabaseCallbacksImpl.h: Copied from Source/WebCore/storage/IDBVersionChangeEvent.h.
     25        * src/WebIDBDatabaseImpl.cpp:
     26        (WebKit::WebIDBDatabaseImpl::setVersion):
     27        (WebKit::WebIDBDatabaseImpl::close):
     28        (WebKit::WebIDBDatabaseImpl::open):
     29        * src/WebIDBDatabaseImpl.h:
     30
    1312011-03-02  Sheriff Bot  <webkit.review.bot@gmail.com>
    232

  • trunk/Source/WebKit/chromium/WebKit.gyp

    r80087 r80183  
    363363                'src/IDBCursorBackendProxy.cpp',
    364364                'src/IDBCursorBackendProxy.h',
     365                'src/IDBDatabaseCallbacksProxy.cpp',
     366                'src/IDBDatabaseCallbacksProxy.h',
    365367                'src/IDBDatabaseProxy.cpp',
    366368                'src/IDBDatabaseProxy.h',
    … …  
    479481                'src/WebIDBCursorImpl.cpp',
    480482                'src/WebIDBCursorImpl.h',
     483                'src/WebIDBDatabaseCallbacksImpl.cpp',
     484                'src/WebIDBDatabaseCallbacksImpl.h',
    481485                'src/WebIDBDatabaseError.cpp',
    482486                'src/WebIDBDatabaseImpl.cpp',

  • trunk/Source/WebKit/chromium/src/IDBDatabaseCallbacksProxy.cpp

    r80182 r80183  
    2424 */
    2525
    26 #ifndef IDBVersionChangeEvent_h
    27 #define IDBVersionChangeEvent_h
     26#include "config.h"
     27#include "IDBDatabaseCallbacksProxy.h"
    2828
    2929#if ENABLE(INDEXED_DATABASE)
    3030
    31 #include "Event.h"
    32 #include "PlatformString.h"
    33 #include <wtf/PassRefPtr.h>
    34 #include <wtf/RefPtr.h>
     31#include "WebIDBDatabaseCallbacks.h"
    3532
    3633namespace WebCore {
    3734
    38 class IDBAny;
     35PassRefPtr<IDBDatabaseCallbacksProxy> IDBDatabaseCallbacksProxy::create(PassOwnPtr<WebKit::WebIDBDatabaseCallbacks> callbacks)
     36{
     37    return adoptRef(new IDBDatabaseCallbacksProxy(callbacks));
     38}
    3939
    40 class IDBVersionChangeEvent : public Event {
    41 public:
    42     static PassRefPtr<IDBVersionChangeEvent> create(const String& version);
    43     // FIXME: Need to allow creation of these events from JS.
    44     virtual ~IDBVersionChangeEvent();
     40IDBDatabaseCallbacksProxy::IDBDatabaseCallbacksProxy(PassOwnPtr<WebKit::WebIDBDatabaseCallbacks> callbacks)
     41    : m_callbacks(callbacks)
     42{
     43}
    4544
    46     virtual bool isIDBVersionChangeEvent() const { return true; }
     45IDBDatabaseCallbacksProxy::~IDBDatabaseCallbacksProxy()
     46{
     47}
    4748
    48     virtual String version();
    49 
    50 private:
    51     IDBVersionChangeEvent(const String& version);
    52 
    53     String m_version;
    54 };
     49void IDBDatabaseCallbacksProxy::onVersionChange(const String& requestedVersion)
     50{
     51    m_callbacks->onVersionChange(requestedVersion);
     52}
    5553
    5654} // namespace WebCore
    5755
    5856#endif // ENABLE(INDEXED_DATABASE)
    59 
    60 #endif // IDBVersionChangeEvent_h

  • trunk/Source/WebKit/chromium/src/IDBDatabaseCallbacksProxy.h

    r80182 r80183  
    2424 */
    2525
    26 #ifndef IDBVersionChangeEvent_h
    27 #define IDBVersionChangeEvent_h
     26#ifndef IDBDatabaseCallbacksProxy_h
     27#define IDBDatabaseCallbacksProxy_h
     28
     29#include "IDBDatabaseCallbacks.h"
    2830
    2931#if ENABLE(INDEXED_DATABASE)
    3032
    31 #include "Event.h"
    32 #include "PlatformString.h"
    33 #include <wtf/PassRefPtr.h>
    34 #include <wtf/RefPtr.h>
     33#include <wtf/PassOwnPtr.h>
     34
     35namespace WebKit { class WebIDBDatabaseCallbacks; }
    3536
    3637namespace WebCore {
    3738
    38 class IDBAny;
     39class IDBDatabaseCallbacksProxy : public IDBDatabaseCallbacks {
     40public:
     41    static PassRefPtr<IDBDatabaseCallbacksProxy> create(PassOwnPtr<WebKit::WebIDBDatabaseCallbacks>);
     42    virtual ~IDBDatabaseCallbacksProxy();
    3943
    40 class IDBVersionChangeEvent : public Event {
    41 public:
    42     static PassRefPtr<IDBVersionChangeEvent> create(const String& version);
    43     // FIXME: Need to allow creation of these events from JS.
    44     virtual ~IDBVersionChangeEvent();
    45 
    46     virtual bool isIDBVersionChangeEvent() const { return true; }
    47 
    48     virtual String version();
     44    virtual void onVersionChange(const String& requestedVersion);
    4945
    5046private:
    51     IDBVersionChangeEvent(const String& version);
     47    IDBDatabaseCallbacksProxy(PassOwnPtr<WebKit::WebIDBDatabaseCallbacks>);
    5248
    53     String m_version;
     49    OwnPtr<WebKit::WebIDBDatabaseCallbacks> m_callbacks;
    5450};
    5551
    5652} // namespace WebCore
    5753
    58 #endif // ENABLE(INDEXED_DATABASE)
     54#endif
    5955
    60 #endif // IDBVersionChangeEvent_h
     56#endif // IDBDatabaseCallbacksProxy_h

  • trunk/Source/WebKit/chromium/src/IDBDatabaseProxy.cpp

    r77647 r80183  
    2929#include "DOMStringList.h"
    3030#include "IDBCallbacks.h"
     31#include "IDBDatabaseCallbacks.h"
    3132#include "IDBObjectStoreProxy.h"
    3233#include "IDBTransactionBackendProxy.h"
    … …  
    3536#include "WebIDBCallbacksImpl.h"
    3637#include "WebIDBDatabase.h"
     38#include "WebIDBDatabaseCallbacksImpl.h"
    3739#include "WebIDBDatabaseError.h"
    3840#include "WebIDBObjectStore.h"
    … …  
    9193}
    9294
    93 void IDBDatabaseProxy::setVersion(const String& version, PassRefPtr<IDBCallbacks> callbacks, ExceptionCode& ec)
     95void IDBDatabaseProxy::setVersion(const String& version, PassRefPtr<IDBCallbacks> callbacks, PassRefPtr<IDBDatabaseCallbacks> databaseCallbacks, ExceptionCode& ec)
    9496{
    9597    m_webIDBDatabase->setVersion(version, new WebIDBCallbacksImpl(callbacks), ec);
    … …  
    107109}
    108110
    109 void IDBDatabaseProxy::close()
     111void IDBDatabaseProxy::close(PassRefPtr<IDBDatabaseCallbacks>)
    110112{
    111113    m_webIDBDatabase->close();
     114}
     115
     116void IDBDatabaseProxy::open(PassRefPtr<IDBDatabaseCallbacks> databaseCallbacks)
     117{
     118    m_webIDBDatabase->open(new WebIDBDatabaseCallbacksImpl(databaseCallbacks));
    112119}
    113120

  • trunk/Source/WebKit/chromium/src/IDBDatabaseProxy.h

    r77647 r80183  
    4949    virtual PassRefPtr<IDBObjectStoreBackendInterface> createObjectStore(const String& name, const String& keyPath, bool autoIncrement, IDBTransactionBackendInterface*, ExceptionCode&);
    5050    virtual void deleteObjectStore(const String& name, IDBTransactionBackendInterface*, ExceptionCode&);
    51     virtual void setVersion(const String& version, PassRefPtr<IDBCallbacks>, ExceptionCode&);
     51    virtual void setVersion(const String& version, PassRefPtr<IDBCallbacks>, PassRefPtr<IDBDatabaseCallbacks>, ExceptionCode&);
    5252    virtual PassRefPtr<IDBTransactionBackendInterface> transaction(DOMStringList* storeNames, unsigned short mode, ExceptionCode&);
    53     virtual void close();
     53    virtual void close(PassRefPtr<IDBDatabaseCallbacks>);
     54
     55    virtual void open(PassRefPtr<IDBDatabaseCallbacks>);
    5456
    5557private:

  • trunk/Source/WebKit/chromium/src/WebIDBDatabaseCallbacksImpl.cpp

    r80182 r80183  
    2525
    2626#include "config.h"
    27 #include "IDBVersionChangeEvent.h"
     27#include "WebIDBDatabaseCallbacksImpl.h"
    2828
    2929#if ENABLE(INDEXED_DATABASE)
    3030
    31 #include "EventNames.h"
    32 #include "IDBAny.h"
     31#include "IDBDatabaseCallbacks.h"
     32#include "WebString.h"
    3333
    3434namespace WebCore {
    3535
    36 PassRefPtr<IDBVersionChangeEvent> IDBVersionChangeEvent::create(const String& version)
    37 {
    38     return adoptRef(new IDBVersionChangeEvent(version));
    39 }
    40 
    41 IDBVersionChangeEvent::IDBVersionChangeEvent(const String& version)
    42     : Event(eventNames().blockedEvent, false /*canBubble*/, false /*cancelable*/)
    43     , m_version(version)
     36WebIDBDatabaseCallbacksImpl::WebIDBDatabaseCallbacksImpl(PassRefPtr<IDBDatabaseCallbacks> callbacks)
     37    : m_callbacks(callbacks)
    4438{
    4539}
    4640
    47 IDBVersionChangeEvent::~IDBVersionChangeEvent()
     41WebIDBDatabaseCallbacksImpl::~WebIDBDatabaseCallbacksImpl()
    4842{
    4943}
    5044
    51 String IDBVersionChangeEvent::version()
     45void WebIDBDatabaseCallbacksImpl::onVersionChange(const WebKit::WebString& version)
    5246{
    53     return m_version;
     47    m_callbacks->onVersionChange(version);
    5448}
    5549
    5650} // namespace WebCore
    5751
    58 #endif
     52#endif // ENABLE(INDEXED_DATABASE)

  • trunk/Source/WebKit/chromium/src/WebIDBDatabaseCallbacksImpl.h

    r80182 r80183  
    2424 */
    2525
    26 #ifndef IDBVersionChangeEvent_h
    27 #define IDBVersionChangeEvent_h
     26#ifndef WebIDBDatabaseCallbacksImpl_h
     27#define WebIDBDatabaseCallbacksImpl_h
    2828
    2929#if ENABLE(INDEXED_DATABASE)
    3030
    31 #include "Event.h"
    32 #include "PlatformString.h"
     31#include "WebDOMStringList.h"
     32#include "WebIDBDatabaseCallbacks.h"
     33#include "WebString.h"
    3334#include <wtf/PassRefPtr.h>
    3435#include <wtf/RefPtr.h>
    … …  
    3637namespace WebCore {
    3738
    38 class IDBAny;
     39class IDBDatabaseCallbacks;
    3940
    40 class IDBVersionChangeEvent : public Event {
     41class WebIDBDatabaseCallbacksImpl : public WebKit::WebIDBDatabaseCallbacks {
    4142public:
    42     static PassRefPtr<IDBVersionChangeEvent> create(const String& version);
    43     // FIXME: Need to allow creation of these events from JS.
    44     virtual ~IDBVersionChangeEvent();
     43    WebIDBDatabaseCallbacksImpl(PassRefPtr<IDBDatabaseCallbacks>);
     44    virtual ~WebIDBDatabaseCallbacksImpl();
    4545
    46     virtual bool isIDBVersionChangeEvent() const { return true; }
    47 
    48     virtual String version();
     46    virtual void onVersionChange(const WebKit::WebString& version);
    4947
    5048private:
    51     IDBVersionChangeEvent(const String& version);
    52 
    53     String m_version;
     49    RefPtr<IDBDatabaseCallbacks> m_callbacks;
    5450};
    5551
    5652} // namespace WebCore
    5753
    58 #endif // ENABLE(INDEXED_DATABASE)
     54#endif
    5955
    60 #endif // IDBVersionChangeEvent_h
     56#endif // WebIDBDatabaseCallbacksImpl_h

  • trunk/Source/WebKit/chromium/src/WebIDBDatabaseImpl.cpp

    r77647 r80183  
    3030#include "IDBCallbacksProxy.h"
    3131#include "IDBDatabaseBackendInterface.h"
     32#include "IDBDatabaseCallbacksProxy.h"
    3233#include "IDBTransactionBackendInterface.h"
    3334#include "WebIDBCallbacks.h"
     35#include "WebIDBDatabaseCallbacks.h"
    3436#include "WebIDBObjectStoreImpl.h"
    3537#include "WebIDBTransactionImpl.h"
    … …  
    8284void WebIDBDatabaseImpl::setVersion(const WebString& version, WebIDBCallbacks* callbacks, WebExceptionCode& ec)
    8385{
    84     m_databaseBackend->setVersion(version, IDBCallbacksProxy::create(callbacks), ec);
     86    m_databaseBackend->setVersion(version, IDBCallbacksProxy::create(callbacks), m_databaseCallbacks, ec);
    8587}
    8688
    … …  
    98100void WebIDBDatabaseImpl::close()
    99101{
    100     m_databaseBackend->close();
     102    // Use the callbacks that ::open gave us so that the backend in
     103    // multi-process chromium knows which database connection is closing.
     104    ASSERT(m_databaseCallbacks);
     105    m_databaseBackend->close(m_databaseCallbacks);
     106}
     107
     108void WebIDBDatabaseImpl::open(WebIDBDatabaseCallbacks* callbacks)
     109{
     110    ASSERT(!m_databaseCallbacks);
     111    m_databaseCallbacks = IDBDatabaseCallbacksProxy::create(callbacks);
     112    m_databaseBackend->open(m_databaseCallbacks);
    101113}
    102114

  • trunk/Source/WebKit/chromium/src/WebIDBDatabaseImpl.h

    r77647 r80183  
    3333#include <wtf/RefPtr.h>
    3434
    35 namespace WebCore { class IDBDatabaseBackendInterface; }
     35namespace WebCore {
     36class IDBDatabaseBackendInterface;
     37class IDBDatabaseCallbacksProxy;
     38}
    3639
    3740namespace WebKit {
    3841
     42class WebIDBDatabaseCallbacks;
    3943class WebIDBObjectStore;
    4044class WebIDBTransaction;
    … …  
    5256    virtual WebIDBObjectStore* createObjectStore(const WebString& name, const WebString& keyPath, bool autoIncrement, const WebIDBTransaction&, WebExceptionCode&);
    5357    virtual void deleteObjectStore(const WebString& name, const WebIDBTransaction&, WebExceptionCode&);
    54     virtual void setVersion(const WebString& version, WebIDBCallbacks* callbacks, WebExceptionCode&);
     58    virtual void setVersion(const WebString& version, WebIDBCallbacks*, WebExceptionCode&);
    5559    virtual WebIDBTransaction* transaction(const WebDOMStringList& names, unsigned short mode, WebExceptionCode&);
    5660    virtual void close();
    5761
     62    virtual void open(WebIDBDatabaseCallbacks*);
     63
    5864private:
    5965    WTF::RefPtr<WebCore::IDBDatabaseBackendInterface> m_databaseBackend;
     66    WTF::RefPtr<WebCore::IDBDatabaseCallbacksProxy> m_databaseCallbacks;
    6067};
    6168
Note: See TracChangeset for help on using the changeset viewer.