Minor IndexedDB refactorings.

third_party/WebKit/Source/modules/indexeddb/IDBCursor.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 43 matching lines @@
     return new IDBCursor(std::move(backend), direction, request, source, transaction);
 }
 
 IDBCursor::IDBCursor(std::unique_ptr<WebIDBCursor> backend, WebIDBCursorDirection direction, IDBRequest* request, IDBAny* source, IDBTransaction* transaction)
     : m_backend(std::move(backend))
     , m_request(request)
     , m_direction(direction)
     , m_source(source)
     , m_transaction(transaction)
 {
-    ASSERT(m_backend);
-    ASSERT(m_request);
-    ASSERT(m_source->getType() == IDBAny::IDBObjectStoreType || m_source->getType() == IDBAny::IDBIndexType);
-    ASSERT(m_transaction);
+    DCHECK(m_backend);
+    DCHECK(m_request);
+    DCHECK(m_source->getType() == IDBAny::IDBObjectStoreType || m_source->getType() == IDBAny::IDBIndexType);
+    DCHECK(m_transaction);
 }
 
 IDBCursor::~IDBCursor()
 {
 }
 
 DEFINE_TRACE(IDBCursor)
 {
     visitor->trace(m_request);
     visitor->trace(m_source);
@@ skipping 214 matching lines @@
     if (isKeyCursor()) {
         exceptionState.throwDOMException(InvalidStateError, IDBDatabase::isKeyCursorErrorMessage);
         return nullptr;
     }
     if (!m_transaction->backendDB()) {
         exceptionState.throwDOMException(InvalidStateError, IDBDatabase::databaseClosedErrorMessage);
         return nullptr;
     }
 
     IDBKeyRange* keyRange = IDBKeyRange::only(m_primaryKey, exceptionState);
-    ASSERT(!exceptionState.hadException());
+    DCHECK(!exceptionState.hadException());
 
     IDBRequest* request = IDBRequest::create(scriptState, IDBAny::create(this), m_transaction.get());
     m_transaction->backendDB()->deleteRange(m_transaction->id(), effectiveObjectStore()->id(), keyRange, WebIDBCallbacksImpl::create(request).release());
     return request;
 }
 
 void IDBCursor::postSuccessHandlerCallback()
 {
     if (m_backend)
         m_backend->postSuccessHandlerCallback();
@@ skipping 13 matching lines @@
 }
 
 ScriptValue IDBCursor::primaryKey(ScriptState* scriptState)
 {
     m_primaryKeyDirty = false;
     return ScriptValue::from(scriptState, m_primaryKey);
 }
 
 ScriptValue IDBCursor::value(ScriptState* scriptState)
 {
-    ASSERT(isCursorWithValue());
+    DCHECK(isCursorWithValue());
 
     IDBObjectStore* objectStore = effectiveObjectStore();
-    const IDBObjectStoreMetadata& metadata = objectStore->metadata();
     IDBAny* value;
     if (!m_value) {
         value = IDBAny::createUndefined();
-    } else if (metadata.autoIncrement && !metadata.keyPath.isNull()) {
-        RefPtr<IDBValue> idbValue = IDBValue::create(m_value.get(), m_primaryKey, metadata.keyPath);
-#if ENABLE(ASSERT)
+    } else if (objectStore->autoIncrement() && !objectStore->idbKeyPath().isNull()) {
+        RefPtr<IDBValue> idbValue = IDBValue::create(m_value.get(), m_primaryKey, objectStore->idbKeyPath());
+#if DCHECK_IS_ON()
         assertPrimaryKeyValidOrInjectable(scriptState, idbValue.get());
-#endif
+#endif // DCHECK_IS_ON()
         value = IDBAny::create(idbValue.release());
     } else {
         value = IDBAny::create(m_value);
     }
 
     m_valueDirty = false;
     ScriptValue scriptValue = ScriptValue::from(scriptState, value);
     return scriptValue;
 }
 
@@ skipping 36 matching lines @@
 {
     if (directionString == IndexedDBNames::next)
         return WebIDBCursorDirectionNext;
     if (directionString == IndexedDBNames::nextunique)
         return WebIDBCursorDirectionNextNoDuplicate;
     if (directionString == IndexedDBNames::prev)
         return WebIDBCursorDirectionPrev;
     if (directionString == IndexedDBNames::prevunique)
         return WebIDBCursorDirectionPrevNoDuplicate;
 
-    ASSERT_NOT_REACHED();
+    NOTREACHED();
     return WebIDBCursorDirectionNext;
 }
 
 const String& IDBCursor::direction() const
 {
     switch (m_direction) {
     case WebIDBCursorDirectionNext:
         return IndexedDBNames::next;
 
     case WebIDBCursorDirectionNextNoDuplicate:
         return IndexedDBNames::nextunique;
 
     case WebIDBCursorDirectionPrev:
         return IndexedDBNames::prev;
 
     case WebIDBCursorDirectionPrevNoDuplicate:
         return IndexedDBNames::prevunique;
 
     default:
-        ASSERT_NOT_REACHED();
+        NOTREACHED();
         return IndexedDBNames::next;
     }
 }
 
 } // namespace blink