code.vuplus.com Git - vuplus_webkit/blob - Source/WebCore/storage/IDBTransaction.cpp

   1 /*
   2  * Copyright (C) 2010 Google Inc. All rights reserved.
   3  *
   4  * Redistribution and use in source and binary forms, with or without
   5  * modification, are permitted provided that the following conditions
   6  * are met:
   7  *
   8  * 1.  Redistributions of source code must retain the above copyright
   9  *     notice, this list of conditions and the following disclaimer.
  10  * 2.  Redistributions in binary form must reproduce the above copyright
  11  *     notice, this list of conditions and the following disclaimer in the
  12  *     documentation and/or other materials provided with the distribution.
  13  *
  14  * THIS SOFTWARE IS PROVIDED BY APPLE AND ITS CONTRIBUTORS "AS IS" AND ANY
  15  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  16  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  17  * DISCLAIMED. IN NO EVENT SHALL APPLE OR ITS CONTRIBUTORS BE LIABLE FOR ANY
  18  * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  19  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  20  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  21  * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  22  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  23  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  24  */
  25
  26 #include "config.h"
  27 #include "IDBTransaction.h"
  28
  29 #if ENABLE(INDEXED_DATABASE)
  30
  31 #include "Document.h"
  32 #include "EventException.h"
  33 #include "EventQueue.h"
  34 #include "IDBDatabase.h"
  35 #include "IDBDatabaseException.h"
  36 #include "IDBEventDispatcher.h"
  37 #include "IDBIndex.h"
  38 #include "IDBObjectStore.h"
  39 #include "IDBObjectStoreBackendInterface.h"
  40 #include "IDBPendingTransactionMonitor.h"
  41
  42 namespace WebCore {
  43
  44 PassRefPtr<IDBTransaction> IDBTransaction::create(ScriptExecutionContext* context, PassRefPtr<IDBTransactionBackendInterface> backend, IDBDatabase* db)
  45 {
  46     return adoptRef(new IDBTransaction(context, backend, db));
  47 }
  48
  49 IDBTransaction::IDBTransaction(ScriptExecutionContext* context, PassRefPtr<IDBTransactionBackendInterface> backend, IDBDatabase* db)
  50     : ActiveDOMObject(context, this)
  51     , m_backend(backend)
  52     , m_database(db)
  53     , m_mode(m_backend->mode())
  54     , m_finished(false)
  55 {
  56     ASSERT(m_backend);
  57     IDBPendingTransactionMonitor::addPendingTransaction(m_backend.get());
  58 }
  59
  60 IDBTransaction::~IDBTransaction()
  61 {
  62 }
  63
  64 IDBTransactionBackendInterface* IDBTransaction::backend() const
  65 {
  66     return m_backend.get();
  67 }
  68
  69 bool IDBTransaction::finished() const
  70 {
  71     return m_finished;
  72 }
  73
  74 unsigned short IDBTransaction::mode() const
  75 {
  76     return m_mode;
  77 }
  78
  79 IDBDatabase* IDBTransaction::db() const
  80 {
  81     return m_database.get();
  82 }
  83
  84 PassRefPtr<IDBObjectStore> IDBTransaction::objectStore(const String& name, ExceptionCode& ec)
  85 {
  86     if (m_finished) {
  87         ec = IDBDatabaseException::NOT_ALLOWED_ERR;
  88         return 0;
  89     }
  90     RefPtr<IDBObjectStoreBackendInterface> objectStoreBackend = m_backend->objectStore(name, ec);
  91     if (!objectStoreBackend) {
  92         ASSERT(ec);
  93         return 0;
  94     }
  95     RefPtr<IDBObjectStore> objectStore = IDBObjectStore::create(objectStoreBackend, this);
  96     return objectStore.release();
  97 }
  98
  99 void IDBTransaction::abort()
 100 {
 101     RefPtr<IDBTransaction> selfRef = this;
 102     if (m_backend)
 103         m_backend->abort();
 104 }
 105
 106 void IDBTransaction::registerRequest(IDBRequest* request)
 107 {
 108     m_childRequests.add(request);
 109 }
 110
 111 void IDBTransaction::unregisterRequest(IDBRequest* request)
 112 {
 113     // If we aborted the request, it will already have been removed.
 114     m_childRequests.remove(request);
 115 }
 116
 117 void IDBTransaction::onAbort()
 118 {
 119     while (!m_childRequests.isEmpty()) {
 120         IDBRequest* request = *m_childRequests.begin();
 121         m_childRequests.remove(request);
 122         request->abort();
 123     }
 124
 125     enqueueEvent(Event::create(eventNames().abortEvent, true, false));
 126 }
 127
 128 void IDBTransaction::onComplete()
 129 {
 130     enqueueEvent(Event::create(eventNames().completeEvent, false, false));
 131 }
 132
 133 bool IDBTransaction::hasPendingActivity() const
 134 {
 135     // FIXME: In an ideal world, we should return true as long as anyone has a or can
 136     //        get a handle to us or any child request object and any of those have
 137     //        event listeners. This is  in order to handle user generated events properly.
 138     return !m_finished || ActiveDOMObject::hasPendingActivity();
 139 }
 140
 141 ScriptExecutionContext* IDBTransaction::scriptExecutionContext() const
 142 {
 143     return ActiveDOMObject::scriptExecutionContext();
 144 }
 145
 146 bool IDBTransaction::dispatchEvent(PassRefPtr<Event> event)
 147 {
 148     ASSERT(!m_finished);
 149     ASSERT(scriptExecutionContext());
 150     ASSERT(event->target() == this);
 151     ASSERT(!m_finished);
 152     m_finished = true;
 153
 154     Vector<RefPtr<EventTarget> > targets;
 155     targets.append(this);
 156     targets.append(db());
 157
 158     // FIXME: When we allow custom event dispatching, this will probably need to change.
 159     ASSERT(event->type() == eventNames().completeEvent || event->type() == eventNames().abortEvent);
 160     return IDBEventDispatcher::dispatch(event.get(), targets);
 161 }
 162
 163 bool IDBTransaction::canSuspend() const
 164 {
 165     // FIXME: Technically we can suspend before the first request is schedule
 166     //        and after the complete/abort event is enqueued.
 167     return m_finished;
 168 }
 169
 170 void IDBTransaction::contextDestroyed()
 171 {
 172     ActiveDOMObject::contextDestroyed();
 173
 174     // Must happen in contextDestroyed since it can result in ActiveDOMObjects being destructed
 175     // (and contextDestroyed is the only one resilient against this).
 176     RefPtr<IDBTransaction> selfRef = this;
 177     if (m_backend)
 178         m_backend->abort();
 179
 180     m_finished = true;
 181 }
 182
 183 void IDBTransaction::enqueueEvent(PassRefPtr<Event> event)
 184 {
 185     ASSERT_WITH_MESSAGE(!m_finished, "A finished transaction tried to enqueue an event of type %s.", event->type().string().utf8().data());
 186     if (!scriptExecutionContext())
 187         return;
 188
 189     ASSERT(scriptExecutionContext()->isDocument());
 190     EventQueue* eventQueue = static_cast<Document*>(scriptExecutionContext())->eventQueue();
 191     event->setTarget(this);
 192     eventQueue->enqueueEvent(event);
 193 }
 194
 195 EventTargetData* IDBTransaction::eventTargetData()
 196 {
 197     return &m_eventTargetData;
 198 }
 199
 200 EventTargetData* IDBTransaction::ensureEventTargetData()
 201 {
 202     return &m_eventTargetData;
 203 }
 204
 205 }
 206
 207 #endif // ENABLE(INDEXED_DATABASE)