Minor IndexedDB refactorings.

third_party/WebKit/Source/modules/indexeddb/IDBIndex.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 32 matching lines @@
 using blink::WebIDBCursor;
 using blink::WebIDBDatabase;
 
 namespace blink {
 
 IDBIndex::IDBIndex(const IDBIndexMetadata& metadata, IDBObjectStore* objectStore, IDBTransaction* transaction)
     : m_metadata(metadata)
     , m_objectStore(objectStore)
     , m_transaction(transaction)
 {
-    ASSERT(m_objectStore);
-    ASSERT(m_transaction);
-    ASSERT(m_metadata.id != IDBIndexMetadata::InvalidId);
+    DCHECK(m_objectStore);
+    DCHECK(m_transaction);
+    DCHECK(id() != IDBIndexMetadata::InvalidId);

[cmumford, 2016/09/19 23:26:48]

DCHECK_NE

[pwnall, 2016/09/20 09:11:14]

Done.

TBH, I was trying to be smart and thinking that the message wouldn't be so
useful. But it's much easier (as a rule) to do DCHECK_NE whenever possible, so I
did that in all the files I changed.

 }
 
 IDBIndex::~IDBIndex()
 {
 }
 
 DEFINE_TRACE(IDBIndex)
 {
     visitor->trace(m_objectStore);
     visitor->trace(m_transaction);
 }
 
-void IDBIndex::setName(const String& name, ExceptionState& exceptionState)
+void IDBIndex::setName(const String& newName, ExceptionState& exceptionState)

[cmumford, 2016/09/19 23:26:48]

Nit: Several other Blink "setName" methods use "name" for this parameter. The
only other place in Blink where "newName" is used is when there is also an
"oldName" variable. Was this just done for clarity?

Note: Just a minor nit, I don't feel strongly about this, but the prior
implementation does seem to conform better with other Blink code.

[pwnall, 2016/09/20 09:11:14]

Done.

I was mostly trying to avoid if (this->name() == name)

 {
     if (!RuntimeEnabledFeatures::indexedDBExperimentalEnabled())
         return;
 
     IDB_TRACE("IDBIndex::setName");
     if (!m_transaction->isVersionChange()) {
         exceptionState.throwDOMException(InvalidStateError, IDBDatabase::notVersionChangeTransactionErrorMessage);
         return;
     }
     if (isDeleted()) {
         exceptionState.throwDOMException(InvalidStateError, IDBDatabase::indexDeletedErrorMessage);
         return;
     }
     if (m_transaction->isFinished() || m_transaction->isFinishing()) {
         exceptionState.throwDOMException(TransactionInactiveError, IDBDatabase::transactionFinishedErrorMessage);
         return;
     }
     if (!m_transaction->isActive()) {
         exceptionState.throwDOMException(TransactionInactiveError, IDBDatabase::transactionInactiveErrorMessage);
         return;
     }
 
-    if (m_metadata.name == name)
+    if (name() == newName)
         return;
-    if (m_objectStore->containsIndex(name)) {
+    if (m_objectStore->containsIndex(newName)) {
         exceptionState.throwDOMException(ConstraintError, IDBDatabase::indexNameTakenErrorMessage);
         return;
     }
     if (!backendDB()) {
         exceptionState.throwDOMException(InvalidStateError, IDBDatabase::databaseClosedErrorMessage);
         return;
     }
 
-    backendDB()->renameIndex(m_transaction->id(), m_objectStore->id(), id(), name);
-    m_metadata.name = name;
-    m_objectStore->indexRenamed(m_metadata.id, name);
-    m_transaction->db()->indexRenamed(m_objectStore->id(), id(), name);
+    backendDB()->renameIndex(m_transaction->id(), m_objectStore->id(), id(), newName);
+    m_metadata.name = newName;
+    m_objectStore->indexRenamed(m_metadata.id, newName);
+    m_transaction->db()->indexRenamed(m_objectStore->id(), id(), newName);
 }
 
 ScriptValue IDBIndex::keyPath(ScriptState* scriptState) const
 {
-    return ScriptValue::from(scriptState, m_metadata.keyPath);
+    return ScriptValue::from(scriptState, metadata().keyPath);
 }
 
 IDBRequest* IDBIndex::openCursor(ScriptState* scriptState, const ScriptValue& range, const String& directionString, ExceptionState& exceptionState)
 {
     IDB_TRACE("IDBIndex::openCursor");
     if (isDeleted()) {
         exceptionState.throwDOMException(InvalidStateError, IDBDatabase::indexDeletedErrorMessage);
         return nullptr;
     }
     if (m_transaction->isFinished() || m_transaction->isFinishing()) {
@@ skipping 14 matching lines @@
         return nullptr;
     }
 
     return openCursor(scriptState, keyRange, direction);
 }
 
 IDBRequest* IDBIndex::openCursor(ScriptState* scriptState, IDBKeyRange* keyRange, WebIDBCursorDirection direction)
 {
     IDBRequest* request = IDBRequest::create(scriptState, IDBAny::create(this), m_transaction.get());
     request->setCursorDetails(IndexedDB::CursorKeyAndValue, direction);
-    backendDB()->openCursor(m_transaction->id(), m_objectStore->id(), m_metadata.id, keyRange, direction, false, WebIDBTaskTypeNormal, WebIDBCallbacksImpl::create(request).release());
+    backendDB()->openCursor(m_transaction->id(), m_objectStore->id(), id(), keyRange, direction, false, WebIDBTaskTypeNormal, WebIDBCallbacksImpl::create(request).release());
     return request;
 }
 
 IDBRequest* IDBIndex::count(ScriptState* scriptState, const ScriptValue& range, ExceptionState& exceptionState)
 {
     IDB_TRACE("IDBIndex::count");
     if (isDeleted()) {
         exceptionState.throwDOMException(InvalidStateError, IDBDatabase::indexDeletedErrorMessage);
         return nullptr;
     }
     if (m_transaction->isFinished() || m_transaction->isFinishing()) {
         exceptionState.throwDOMException(TransactionInactiveError, IDBDatabase::transactionFinishedErrorMessage);
         return nullptr;
     }
     if (!m_transaction->isActive()) {
         exceptionState.throwDOMException(TransactionInactiveError, IDBDatabase::transactionInactiveErrorMessage);
         return nullptr;
     }
 
     IDBKeyRange* keyRange = IDBKeyRange::fromScriptValue(scriptState->getExecutionContext(), range, exceptionState);
     if (exceptionState.hadException())
         return nullptr;
 
     if (!backendDB()) {
         exceptionState.throwDOMException(InvalidStateError, IDBDatabase::databaseClosedErrorMessage);
         return nullptr;
     }
 
     IDBRequest* request = IDBRequest::create(scriptState, IDBAny::create(this), m_transaction.get());
-    backendDB()->count(m_transaction->id(), m_objectStore->id(), m_metadata.id, keyRange, WebIDBCallbacksImpl::create(request).release());
+    backendDB()->count(m_transaction->id(), m_objectStore->id(), id(), keyRange, WebIDBCallbacksImpl::create(request).release());
     return request;
 }
 
 IDBRequest* IDBIndex::openKeyCursor(ScriptState* scriptState, const ScriptValue& range, const String& directionString, ExceptionState& exceptionState)
 {
     IDB_TRACE("IDBIndex::openKeyCursor");
     if (isDeleted()) {
         exceptionState.throwDOMException(InvalidStateError, IDBDatabase::indexDeletedErrorMessage);
         return nullptr;
     }
     if (m_transaction->isFinished() || m_transaction->isFinishing()) {
         exceptionState.throwDOMException(TransactionInactiveError, IDBDatabase::transactionFinishedErrorMessage);
         return nullptr;
     }
     if (!m_transaction->isActive()) {
         exceptionState.throwDOMException(TransactionInactiveError, IDBDatabase::transactionInactiveErrorMessage);
         return nullptr;
     }
     WebIDBCursorDirection direction = IDBCursor::stringToDirection(directionString);
     IDBKeyRange* keyRange = IDBKeyRange::fromScriptValue(scriptState->getExecutionContext(), range, exceptionState);
     if (exceptionState.hadException())
         return nullptr;
     if (!backendDB()) {
         exceptionState.throwDOMException(InvalidStateError, IDBDatabase::databaseClosedErrorMessage);
         return nullptr;
     }
 
     IDBRequest* request = IDBRequest::create(scriptState, IDBAny::create(this), m_transaction.get());
     request->setCursorDetails(IndexedDB::CursorKeyOnly, direction);
-    backendDB()->openCursor(m_transaction->id(), m_objectStore->id(), m_metadata.id, keyRange, direction, true, WebIDBTaskTypeNormal, WebIDBCallbacksImpl::create(request).release());
+    backendDB()->openCursor(m_transaction->id(), m_objectStore->id(), id(), keyRange, direction, true, WebIDBTaskTypeNormal, WebIDBCallbacksImpl::create(request).release());
     return request;
 }
 
 IDBRequest* IDBIndex::get(ScriptState* scriptState, const ScriptValue& key, ExceptionState& exceptionState)
 {
     IDB_TRACE("IDBIndex::get");
     return getInternal(scriptState, key, exceptionState, false);
 }
 
 IDBRequest* IDBIndex::getAll(ScriptState* scriptState, const ScriptValue& range, ExceptionState& exceptionState)
@@ skipping 45 matching lines @@
     if (!keyRange) {
         exceptionState.throwDOMException(DataError, IDBDatabase::noKeyOrKeyRangeErrorMessage);
         return nullptr;
     }
     if (!backendDB()) {
         exceptionState.throwDOMException(InvalidStateError, IDBDatabase::databaseClosedErrorMessage);
         return nullptr;
     }
 
     IDBRequest* request = IDBRequest::create(scriptState, IDBAny::create(this), m_transaction.get());
-    backendDB()->get(m_transaction->id(), m_objectStore->id(), m_metadata.id, keyRange, keyOnly, WebIDBCallbacksImpl::create(request).release());
+    backendDB()->get(m_transaction->id(), m_objectStore->id(), id(), keyRange, keyOnly, WebIDBCallbacksImpl::create(request).release());
     return request;
 }
 
 IDBRequest* IDBIndex::getAllInternal(ScriptState* scriptState, const ScriptValue& range, unsigned long maxCount, ExceptionState& exceptionState, bool keyOnly)
 {
     if (!maxCount)
         maxCount = std::numeric_limits<uint32_t>::max();
 
     if (isDeleted()) {
         exceptionState.throwDOMException(InvalidStateError, IDBDatabase::indexDeletedErrorMessage);
@@ skipping 10 matching lines @@
 
     IDBKeyRange* keyRange = IDBKeyRange::fromScriptValue(scriptState->getExecutionContext(), range, exceptionState);
     if (exceptionState.hadException())
         return nullptr;
     if (!backendDB()) {
         exceptionState.throwDOMException(InvalidStateError, IDBDatabase::databaseClosedErrorMessage);
         return nullptr;
     }
 
     IDBRequest* request = IDBRequest::create(scriptState, IDBAny::create(this), m_transaction.get());
-    backendDB()->getAll(m_transaction->id(), m_objectStore->id(), m_metadata.id, keyRange, maxCount, keyOnly, WebIDBCallbacksImpl::create(request).release());
+    backendDB()->getAll(m_transaction->id(), m_objectStore->id(), id(), keyRange, maxCount, keyOnly, WebIDBCallbacksImpl::create(request).release());
     return request;
 }
 
 WebIDBDatabase* IDBIndex::backendDB() const
 {
     return m_transaction->backendDB();
 }
 
 bool IDBIndex::isDeleted() const
 {
     return m_deleted || m_objectStore->isDeleted();
 }
 
 } // namespace blink