Minor IndexedDB refactorings.

third_party/WebKit/Source/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 53 matching lines @@
     : ActiveScriptWrappable(this)
     , ActiveDOMObject(scriptState->getExecutionContext())
     , m_transaction(transaction)
     , m_scriptState(scriptState)
     , m_source(source)
 {
 }
 
 IDBRequest::~IDBRequest()
 {
-    ASSERT(m_readyState == DONE || m_readyState == EarlyDeath || !getExecutionContext());
+    DCHECK(m_readyState == DONE || m_readyState == EarlyDeath || !getExecutionContext());
 }
 
 DEFINE_TRACE(IDBRequest)
 {
     visitor->trace(m_transaction);
     visitor->trace(m_source);
     visitor->trace(m_result);
     visitor->trace(m_error);
     visitor->trace(m_enqueuedEvents);
     visitor->trace(m_pendingCursor);
@@ skipping 31 matching lines @@
 ScriptValue IDBRequest::source() const
 {
     if (m_contextStopped || !getExecutionContext())
         return ScriptValue();
 
     return ScriptValue::from(m_scriptState.get(), m_source);
 }
 
 const String& IDBRequest::readyState() const
 {
-    ASSERT(m_readyState == PENDING || m_readyState == DONE);
+    DCHECK(m_readyState == PENDING || m_readyState == DONE);
 
     if (m_readyState == PENDING)
         return IndexedDBNames::pending;
 
     return IndexedDBNames::done;
 }
 
 void IDBRequest::abort()
 {
-    ASSERT(!m_requestAborted);
+    DCHECK(!m_requestAborted);
     if (m_contextStopped || !getExecutionContext())
         return;
-    ASSERT(m_readyState == PENDING || m_readyState == DONE);
+    DCHECK(m_readyState == PENDING || m_readyState == DONE);
     if (m_readyState == DONE)
         return;
 
     EventQueue* eventQueue = getExecutionContext()->getEventQueue();
     for (size_t i = 0; i < m_enqueuedEvents.size(); ++i) {
         bool removed = eventQueue->cancelEvent(m_enqueuedEvents[i].get());
         ASSERT_UNUSED(removed, removed);
     }
     m_enqueuedEvents.clear();
 
     m_error.clear();
     m_result.clear();
     onError(DOMException::create(AbortError, "The transaction was aborted, so the request cannot be fulfilled."));
     m_requestAborted = true;
 }
 
 void IDBRequest::setCursorDetails(IndexedDB::CursorType cursorType, WebIDBCursorDirection direction)
 {
-    ASSERT(m_readyState == PENDING);
-    ASSERT(!m_pendingCursor);
+    DCHECK_EQ(m_readyState, PENDING);
+    DCHECK(!m_pendingCursor);
     m_cursorType = cursorType;
     m_cursorDirection = direction;
 }
 
 void IDBRequest::setPendingCursor(IDBCursor* cursor)
 {
-    ASSERT(m_readyState == DONE);
-    ASSERT(getExecutionContext());
-    ASSERT(m_transaction);
-    ASSERT(!m_pendingCursor);
-    ASSERT(cursor == getResultCursor());
+    DCHECK_EQ(m_readyState, DONE);
+    DCHECK(getExecutionContext());
+    DCHECK(m_transaction);
+    DCHECK(!m_pendingCursor);
+    DCHECK_EQ(cursor, getResultCursor());
 
     m_hasPendingActivity = true;
     m_pendingCursor = cursor;
     setResult(nullptr);
     m_readyState = PENDING;
     m_error.clear();
     m_transaction->registerRequest(this);
 }
 
 IDBCursor* IDBRequest::getResultCursor() const
 {
     if (!m_result)
         return nullptr;
     if (m_result->getType() == IDBAny::IDBCursorType)
         return m_result->idbCursor();
     if (m_result->getType() == IDBAny::IDBCursorWithValueType)
         return m_result->idbCursorWithValue();
     return nullptr;
 }
 
 void IDBRequest::setResultCursor(IDBCursor* cursor, IDBKey* key, IDBKey* primaryKey, PassRefPtr<IDBValue> value)
 {
-    ASSERT(m_readyState == PENDING);
+    DCHECK_EQ(m_readyState, PENDING);
     m_cursorKey = key;
     m_cursorPrimaryKey = primaryKey;
     m_cursorValue = value;
     ackReceivedBlobs(m_cursorValue.get());
 
     onSuccessInternal(IDBAny::create(cursor));
 }
 
 void IDBRequest::ackReceivedBlobs(const IDBValue* value)
 {
     if (!m_transaction || !m_transaction->backendDB())
         return;
     Vector<String> uuids = value->getUUIDs();
     if (!uuids.isEmpty())
         m_transaction->backendDB()->ackReceivedBlobs(uuids);
 }
 
 void IDBRequest::ackReceivedBlobs(const Vector<RefPtr<IDBValue>>& values)
 {
     for (size_t i = 0; i < values.size(); ++i)
         ackReceivedBlobs(values[i].get());
 }
 
 bool IDBRequest::shouldEnqueueEvent() const
 {
     if (m_contextStopped || !getExecutionContext())
         return false;
-    ASSERT(m_readyState == PENDING || m_readyState == DONE);
+    DCHECK(m_readyState == PENDING || m_readyState == DONE);
     if (m_requestAborted)
         return false;
-    ASSERT(m_readyState == PENDING);
-    ASSERT(!m_error && !m_result);
+    DCHECK_EQ(m_readyState, PENDING);
+    DCHECK(!m_error && !m_result);
     return true;
 }
 
 void IDBRequest::onError(DOMException* error)
 {
     IDB_TRACE("IDBRequest::onError()");
     if (!shouldEnqueueEvent())
         return;
 
     m_error = error;
@@ skipping 13 matching lines @@
         domStringList->append(stringList[i]);
     onSuccessInternal(IDBAny::create(domStringList));
 }
 
 void IDBRequest::onSuccess(std::unique_ptr<WebIDBCursor> backend, IDBKey* key, IDBKey* primaryKey, PassRefPtr<IDBValue> value)
 {
     IDB_TRACE("IDBRequest::onSuccess(IDBCursor)");
     if (!shouldEnqueueEvent())
         return;
 
-    ASSERT(!m_pendingCursor);
+    DCHECK(!m_pendingCursor);
     IDBCursor* cursor = nullptr;
     switch (m_cursorType) {
     case IndexedDB::CursorKeyOnly:
         cursor = IDBCursor::create(std::move(backend), m_cursorDirection, this, m_source.get(), m_transaction.get());
         break;
     case IndexedDB::CursorKeyAndValue:
         cursor = IDBCursorWithValue::create(std::move(backend), m_cursorDirection, this, m_source.get(), m_transaction.get());
         break;
     default:
-        ASSERT_NOT_REACHED();
+        NOTREACHED();
     }
     setResultCursor(cursor, key, primaryKey, std::move(value));
 }
 
 void IDBRequest::onSuccess(IDBKey* idbKey)
 {
     IDB_TRACE("IDBRequest::onSuccess(IDBKey)");
     if (!shouldEnqueueEvent())
         return;
 
     if (idbKey && idbKey->isValid())
         onSuccessInternal(IDBAny::create(idbKey));
     else
         onSuccessInternal(IDBAny::createUndefined());
 }
 
 void IDBRequest::onSuccess(const Vector<RefPtr<IDBValue>>& values)
 {
     IDB_TRACE("IDBRequest::onSuccess([IDBValue])");
     if (!shouldEnqueueEvent())
         return;
 
     ackReceivedBlobs(values);
     onSuccessInternal(IDBAny::create(values));
 }
 
-#if ENABLE(ASSERT)
+#if DCHECK_IS_ON()
 static IDBObjectStore* effectiveObjectStore(IDBAny* source)
 {
     if (source->getType() == IDBAny::IDBObjectStoreType)
         return source->idbObjectStore();
     if (source->getType() == IDBAny::IDBIndexType)
         return source->idbIndex()->objectStore();
 
-    ASSERT_NOT_REACHED();
+    NOTREACHED();
     return nullptr;
 }
-#endif
+#endif // DCHECK_IS_ON()
 
 void IDBRequest::onSuccess(PassRefPtr<IDBValue> prpValue)
 {
     IDB_TRACE("IDBRequest::onSuccess(IDBValue)");
     if (!shouldEnqueueEvent())
         return;
 
     RefPtr<IDBValue> value(prpValue);
     ackReceivedBlobs(value.get());
 
     if (m_pendingCursor) {
         // Value should be null, signifying the end of the cursor's range.
-        ASSERT(value->isNull());
-        ASSERT(!value->blobInfo()->size());
+        DCHECK(value->isNull());
+        DCHECK(!value->blobInfo()->size());
         m_pendingCursor->close();
         m_pendingCursor.clear();
     }
 
-#if ENABLE(ASSERT)
+#if DCHECK_IS_ON()
     if (value->primaryKey()) {
-        ASSERT(value->keyPath() == effectiveObjectStore(m_source)->metadata().keyPath);
+        DCHECK(value->keyPath() == effectiveObjectStore(m_source)->idbKeyPath());
         assertPrimaryKeyValidOrInjectable(m_scriptState.get(), value.get());
     }
-#endif
+#endif // DCHECK_IS_ON()
 
     onSuccessInternal(IDBAny::create(value.release()));
 }
 
 void IDBRequest::onSuccess(int64_t value)
 {
     IDB_TRACE("IDBRequest::onSuccess(int64_t)");
     if (!shouldEnqueueEvent())
         return;
     onSuccessInternal(IDBAny::create(value));
 }
 
 void IDBRequest::onSuccess()
 {
     IDB_TRACE("IDBRequest::onSuccess()");
     if (!shouldEnqueueEvent())
         return;
     onSuccessInternal(IDBAny::createUndefined());
 }
 
 void IDBRequest::onSuccessInternal(IDBAny* result)
 {
-    ASSERT(!m_contextStopped);
-    ASSERT(!m_pendingCursor);
+    DCHECK(!m_contextStopped);
+    DCHECK(!m_pendingCursor);
     setResult(result);
     enqueueEvent(Event::create(EventTypeNames::success));
 }
 
 void IDBRequest::setResult(IDBAny* result)
 {
     m_result = result;
     m_resultDirty = true;
 }
 
 void IDBRequest::onSuccess(IDBKey* key, IDBKey* primaryKey, PassRefPtr<IDBValue> value)
 {
     IDB_TRACE("IDBRequest::onSuccess(key, primaryKey, value)");
     if (!shouldEnqueueEvent())
         return;
 
-    ASSERT(m_pendingCursor);
+    DCHECK(m_pendingCursor);
     setResultCursor(m_pendingCursor.release(), key, primaryKey, std::move(value));
 }
 
 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
     //        user generated events properly.
     return m_hasPendingActivity && !m_contextStopped;
 }
@@ skipping 30 matching lines @@
 ExecutionContext* IDBRequest::getExecutionContext() const
 {
     return ActiveDOMObject::getExecutionContext();
 }
 
 DispatchEventResult IDBRequest::dispatchEventInternal(Event* event)
 {
     IDB_TRACE("IDBRequest::dispatchEvent");
     if (m_contextStopped || !getExecutionContext())
         return DispatchEventResult::CanceledBeforeDispatch;
-    ASSERT(m_readyState == PENDING);
-    ASSERT(m_hasPendingActivity);
-    ASSERT(m_enqueuedEvents.size());
-    ASSERT(event->target() == this);
+    DCHECK_EQ(m_readyState, PENDING);
+    DCHECK(m_hasPendingActivity);
+    DCHECK(m_enqueuedEvents.size());
+    DCHECK_EQ(event->target(), this);
 
     ScriptState::Scope scope(m_scriptState.get());
 
     if (event->type() != EventTypeNames::blocked)
         m_readyState = DONE;
     dequeueEvent(event);
 
     HeapVector<Member<EventTarget>> targets;
     targets.append(this);
     if (m_transaction && !m_preventPropagation) {
         targets.append(m_transaction);
         // If there ever are events that are associated with a database but
         // that do not have a transaction, then this will not work and we need
         // this object to actually hold a reference to the database (to ensure
         // it stays alive).
         targets.append(m_transaction->db());
     }
 
     // Cursor properties should not be updated until the success event is being dispatched.
     IDBCursor* cursorToNotify = nullptr;
     if (event->type() == EventTypeNames::success) {
         cursorToNotify = getResultCursor();
         if (cursorToNotify)
             cursorToNotify->setValueReady(m_cursorKey.release(), m_cursorPrimaryKey.release(), m_cursorValue.release());
     }
 
     if (event->type() == EventTypeNames::upgradeneeded) {
-        ASSERT(!m_didFireUpgradeNeededEvent);
+        DCHECK(!m_didFireUpgradeNeededEvent);
         m_didFireUpgradeNeededEvent = true;
     }
 
     // FIXME: When we allow custom event dispatching, this will probably need to change.
     DCHECK(event->type() == EventTypeNames::success || event->type() == EventTypeNames::error || event->type() == EventTypeNames::blocked || event->type() == EventTypeNames::upgradeneeded) << "event type was " << event->type();
     const bool setTransactionActive = m_transaction && (event->type() == EventTypeNames::success || event->type() == EventTypeNames::upgradeneeded || (event->type() == EventTypeNames::error && !m_requestAborted));
 
     if (setTransactionActive)
         m_transaction->setActive(true);
 
@@ skipping 29 matching lines @@
 void IDBRequest::uncaughtExceptionInEventHandler()
 {
     if (m_transaction && !m_requestAborted) {
         m_transaction->setError(DOMException::create(AbortError, "Uncaught exception in event handler."));
         m_transaction->abort(IGNORE_EXCEPTION);
     }
 }
 
 void IDBRequest::transactionDidFinishAndDispatch()
 {
-    ASSERT(m_transaction);
-    ASSERT(m_transaction->isVersionChange());
-    ASSERT(m_didFireUpgradeNeededEvent);
-    ASSERT(m_readyState == DONE);
-    ASSERT(getExecutionContext());
+    DCHECK(m_transaction);
+    DCHECK(m_transaction->isVersionChange());
+    DCHECK(m_didFireUpgradeNeededEvent);
+    DCHECK_EQ(m_readyState, DONE);
+    DCHECK(getExecutionContext());
     m_transaction.clear();
 
     if (m_contextStopped)
         return;
 
     m_readyState = PENDING;
 }
 
 void IDBRequest::enqueueEvent(Event* event)
 {
-    ASSERT(m_readyState == PENDING || m_readyState == DONE);
+    DCHECK(m_readyState == PENDING || m_readyState == DONE);
 
     if (m_contextStopped || !getExecutionContext())
         return;
 
     DCHECK(m_readyState == PENDING || m_didFireUpgradeNeededEvent) << "When queueing event " << event->type() << ", m_readyState was " << m_readyState;
 
     EventQueue* eventQueue = getExecutionContext()->getEventQueue();
     event->setTarget(this);
 
     // Keep track of enqueued events in case we need to abort prior to dispatch,
     // in which case these must be cancelled. If the events not dispatched for
     // other reasons they must be removed from this list via dequeueEvent().
     if (eventQueue->enqueueEvent(event))
         m_enqueuedEvents.append(event);
 }
 
 void IDBRequest::dequeueEvent(Event* event)
 {
     for (size_t i = 0; i < m_enqueuedEvents.size(); ++i) {
         if (m_enqueuedEvents[i].get() == event)
             m_enqueuedEvents.remove(i);
     }
 }
 
 } // namespace blink