自学教程：C++ IDB_TRACE函数代码示例

PassRefPtr<IDBTransaction> IDBDatabase::transaction(ExecutionContext* context, const Vector<String>& scope, const String& modeString, ExceptionState& exceptionState){    IDB_TRACE("IDBDatabase::transaction");    blink::Platform::current()->histogramEnumeration("WebCore.IndexedDB.FrontEndAPICalls", IDBTransactionCall, IDBMethodsMax);    if (!scope.size()) {        exceptionState.throwDOMException(InvalidAccessError, "The storeNames parameter was empty.");        return 0;    }    IndexedDB::TransactionMode mode = IDBTransaction::stringToMode(modeString, exceptionState);    if (exceptionState.hadException())        return 0;    if (m_versionChangeTransaction) {        exceptionState.throwDOMException(InvalidStateError, "A version change transaction is running.");        return 0;    }    if (m_closePending) {        exceptionState.throwDOMException(InvalidStateError, "The database connection is closing.");        return 0;    }    Vector<int64_t> objectStoreIds;    for (size_t i = 0; i < scope.size(); ++i) {        int64_t objectStoreId = findObjectStoreId(scope[i]);        if (objectStoreId == IDBObjectStoreMetadata::InvalidId) {            exceptionState.throwDOMException(NotFoundError, "One of the specified object stores was not found.");            return 0;        }        objectStoreIds.append(objectStoreId);    }    int64_t transactionId = nextTransactionId();    m_backend->createTransaction(transactionId, WebIDBDatabaseCallbacksImpl::create(m_databaseCallbacks).leakPtr(), objectStoreIds, mode);    RefPtr<IDBTransaction> transaction = IDBTransaction::create(context, transactionId, scope, mode, this);    return transaction.release();}

void IDBCursorBackendImpl::continueFunction(PassRefPtr<IDBKey> prpKey, PassRefPtr<IDBCallbacks> prpCallbacks, ExceptionCode& ec){    IDB_TRACE("IDBCursorBackendImpl::continue");    RefPtr<IDBKey> key = prpKey;    if (m_cursor && key) {        ASSERT(m_cursor->key());        if (m_direction == IDBCursor::NEXT || m_direction == IDBCursor::NEXT_NO_DUPLICATE) {            if (!m_cursor->key()->isLessThan(key.get())) {                ec = IDBDatabaseException::DATA_ERR;                return;            }        } else {            if (!key->isLessThan(m_cursor->key().get())) {                ec = IDBDatabaseException::DATA_ERR;                return;            }        }    }    if (!m_transaction->scheduleTask(createCallbackTask(&IDBCursorBackendImpl::continueFunctionInternal, this, key, prpCallbacks)))        ec = IDBDatabaseException::TRANSACTION_INACTIVE_ERR;}

void IDBCursor::advance(unsigned long count, ExceptionCode& ec){    ec = 0;    IDB_TRACE("IDBCursor::advance");    if (!m_gotValue || isDeleted()) {        ec = IDBDatabaseException::InvalidStateError;        return;    }    if (!m_transaction->isActive()) {        ec = IDBDatabaseException::TransactionInactiveError;        return;    }    if (!count) {        ec = TypeError;        return;    }    m_request->setPendingCursor(this);    m_gotValue = false;    m_backend->advance(count, m_request);}

PassRefPtr<IDBKey> createIDBKeyFromScriptValueAndKeyPath(DOMRequestState*, const ScriptValue& value, const IDBKeyPath& keyPath){    IDB_TRACE("createIDBKeyFromScriptValueAndKeyPath");    ASSERT(!keyPath.isNull());    ASSERT(v8::Context::InContext());    v8::HandleScope handleScope;    if (keyPath.type() == IDBKeyPath::ArrayType) {        IDBKey::KeyArray result;        const Vector<String>& array = keyPath.array();        for (size_t i = 0; i < array.size(); ++i) {            RefPtr<IDBKey> key = createIDBKeyFromScriptValueAndKeyPath(value, array[i]);            if (!key)                return 0;            result.append(key);        }        return IDBKey::createArray(result);    }    ASSERT(keyPath.type() == IDBKeyPath::StringType);    return createIDBKeyFromScriptValueAndKeyPath(value, keyPath.string());}

void IDBDatabase::deleteObjectStore(const String& name, ExceptionCode& ec){    IDB_TRACE("IDBDatabase::deleteObjectStore");    HistogramSupport::histogramEnumeration("WebCore.IndexedDB.FrontEndAPICalls", IDBDeleteObjectStoreCall, IDBMethodsMax);    if (!m_versionChangeTransaction) {        ec = IDBDatabaseException::InvalidStateError;        return;    }    if (!m_versionChangeTransaction->isActive()) {        ec = IDBDatabaseException::TransactionInactiveError;        return;    }    int64_t objectStoreId = findObjectStoreId(name);    if (objectStoreId == IDBObjectStoreMetadata::InvalidId) {        ec = IDBDatabaseException::NotFoundError;        return;    }    m_backend->deleteObjectStore(m_versionChangeTransaction->id(), objectStoreId);    m_versionChangeTransaction->objectStoreDeleted(name);    m_metadata.objectStores.remove(objectStoreId);}

bool IDBTransaction::dispatchEvent(PassRefPtrWillBeRawPtr<Event> event){    IDB_TRACE("IDBTransaction::dispatchEvent");    if (m_contextStopped || !executionContext()) {        m_state = Finished;        return false;    }    ASSERT(m_state != Finished);    ASSERT(m_hasPendingActivity);    ASSERT(executionContext());    ASSERT(event->target() == this);    m_state = Finished;    // Break reference cycles.    for (IDBObjectStoreMap::iterator it = m_objectStoreMap.begin(); it != m_objectStoreMap.end(); ++it)        it->value->transactionFinished();    m_objectStoreMap.clear();    for (IDBObjectStoreSet::iterator it = m_deletedObjectStores.begin(); it != m_deletedObjectStores.end(); ++it)        (*it)->transactionFinished();    m_deletedObjectStores.clear();    WillBeHeapVector<RefPtrWillBeMember<EventTarget>> targets;    targets.append(this);    targets.append(db());    // FIXME: When we allow custom event dispatching, this will probably need to change.    ASSERT(event->type() == EventTypeNames::complete || event->type() == EventTypeNames::abort);    bool returnValue = IDBEventDispatcher::dispatch(event.get(), targets);    // FIXME: Try to construct a test where |this| outlives openDBRequest and we    // get a crash.    if (m_openDBRequest) {        ASSERT(isVersionChange());        m_openDBRequest->transactionDidFinishAndDispatch();    }    m_hasPendingActivity = false;    return returnValue;}

void IDBRequest::onSuccess(PassRefPtr<IDBCursorBackendInterface> backend, PassRefPtr<IDBKey> key, PassRefPtr<IDBKey> primaryKey, PassRefPtr<SharedBuffer> buffer){    IDB_TRACE("IDBRequest::onSuccess(IDBCursor)");    if (!shouldEnqueueEvent())        return;    DOMRequestState::Scope scope(m_requestState);    ScriptValue value = deserializeIDBValueBuffer(requestState(), buffer);    ASSERT(!m_pendingCursor);    RefPtr<IDBCursor> cursor;    switch (m_cursorType) {    case IndexedDB::CursorKeyOnly:        cursor = IDBCursor::create(backend, m_cursorDirection, this, m_source.get(), m_transaction.get());        break;    case IndexedDB::CursorKeyAndValue:        cursor = IDBCursorWithValue::create(backend, m_cursorDirection, this, m_source.get(), m_transaction.get());        break;    default:        ASSERT_NOT_REACHED();    }    setResultCursor(cursor, key, primaryKey, value);    enqueueEvent(createSuccessEvent());}

bool injectV8KeyIntoV8Value(v8::Handle<v8::Value> key, v8::Handle<v8::Value> value, const IDBKeyPath& keyPath, v8::Isolate* isolate){    IDB_TRACE("injectIDBV8KeyIntoV8Value");    ASSERT(isolate->InContext());    ASSERT(keyPath.type() == IDBKeyPath::StringType);    Vector<String> keyPathElements;    IDBKeyPathParseError error;    IDBParseKeyPath(keyPath.string(), keyPathElements, error);    ASSERT(error == IDBKeyPathParseErrorNone);    if (!keyPathElements.size())        return false;    v8::HandleScope handleScope(isolate);    v8::Handle<v8::Value> parent(ensureNthValueOnKeyPath(value, keyPathElements, keyPathElements.size() - 1, isolate));    if (parent.IsEmpty())        return false;    if (!set(parent, keyPathElements.last(), key, isolate))        return false;    return true;}

PassRefPtr<IDBIndex> IDBObjectStore::index(const String& name, ExceptionCode& ec){    IDB_TRACE("IDBObjectStore::index");    if (isDeleted()) {        ec = IDBDatabaseException::InvalidStateError;        return 0;    }    if (m_transaction->isFinished()) {        ec = IDBDatabaseException::InvalidStateError;        return 0;    }    IDBIndexMap::iterator it = m_indexMap.find(name);    if (it != m_indexMap.end())        return it->value;    int64_t indexId = findIndexId(name);    if (indexId == IDBIndexMetadata::InvalidId) {        ec = IDBDatabaseException::NotFoundError;        return 0;    }    const IDBIndexMetadata* indexMetadata(0);    for (IDBObjectStoreMetadata::IndexMap::const_iterator it = m_metadata.indexes.begin(); it != m_metadata.indexes.end(); ++it) {        if (it->value.name == name) {            indexMetadata = &it->value;            break;        }    }    ASSERT(indexMetadata);    ASSERT(indexMetadata->id != IDBIndexMetadata::InvalidId);    RefPtr<IDBIndex> index = IDBIndex::create(*indexMetadata, this, m_transaction.get());    m_indexMap.set(name, index);    return index.release();}

void IDBTransaction::onAbort(PassRefPtr<DOMError> prpError){    IDB_TRACE("IDBTransaction::onAbort");    RefPtr<DOMError> error = prpError;    ASSERT(m_state != Finished);    if (m_state != Finishing) {        ASSERT(error.get());        setError(error.release());        // Abort was not triggered by front-end, so outstanding requests must        // be aborted now.        while (!m_requestList.isEmpty()) {            RefPtr<IDBRequest> request = *m_requestList.begin();            m_requestList.remove(request);            request->abort();        }        m_state = Finishing;    }    if (isVersionChange()) {        for (IDBObjectStoreMetadataMap::iterator it = m_objectStoreCleanupMap.begin(); it != m_objectStoreCleanupMap.end(); ++it)            it->key->setMetadata(it->value);        m_database->setMetadata(m_previousMetadata);        m_database->close();    }    m_objectStoreCleanupMap.clear();    closeOpenCursors();    // Enqueue events before notifying database, as database may close which enqueues more events and order matters.    enqueueEvent(Event::create(eventNames().abortEvent, true, false));    // If script has stopped and GC has completed, database may have last reference to this object.    RefPtr<IDBTransaction> protect(this);    m_database->transactionFinished(this);}

void IDBRequest::onSuccess(PassRefPtr<IDBTransactionBackendInterface> prpBackend){    IDB_TRACE("IDBRequest::onSuccess(IDBTransaction)");    RefPtr<IDBTransactionBackendInterface> backend = prpBackend;    if (m_contextStopped || !scriptExecutionContext()) {        // Should only be null in tests.        if (backend.get())            backend->abort();        return;    }    if (!shouldEnqueueEvent())        return;    RefPtr<IDBTransaction> frontend = IDBTransaction::create(scriptExecutionContext(), backend, IDBTransaction::VERSION_CHANGE, m_source->idbDatabase().get());    backend->setCallbacks(frontend.get());    m_transaction = frontend;    ASSERT(m_source->type() == IDBAny::IDBDatabaseType);    ASSERT(m_transaction->isVersionChange());    m_result = IDBAny::create(frontend.release());    enqueueEvent(createSuccessEvent());}

void IDBCursor::advance(long long count, ExceptionCode& ec){    IDB_TRACE("IDBCursor::advance");    if (!m_gotValue) {        ec = IDBDatabaseException::InvalidStateError;        return;    }    if (!m_transaction->isActive()) {        ec = IDBDatabaseException::TransactionInactiveError;        return;    }    // FIXME: This should only need to check for 0 once webkit.org/b/96798 lands.    if (count < 1 || count > UINT_MAX) {        ec = TypeError;        return;    }    m_request->setPendingCursor(this);    m_gotValue = false;    m_backend->advance(count, m_request, ec);    ASSERT(!ec);}

IDBRequest* IDBObjectStore::deleteFunction(ScriptState* scriptState, const ScriptValue& key, ExceptionState& exceptionState){    IDB_TRACE("IDBObjectStore::delete");    if (isDeleted()) {        exceptionState.throwDOMException(InvalidStateError, IDBDatabase::objectStoreDeletedErrorMessage);        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;    }    if (m_transaction->isReadOnly()) {        exceptionState.throwDOMException(ReadOnlyError, IDBDatabase::transactionReadOnlyErrorMessage);        return nullptr;    }    IDBKeyRange* keyRange = IDBKeyRange::fromScriptValue(scriptState->executionContext(), key, exceptionState);    if (exceptionState.hadException())        return nullptr;    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()->deleteRange(m_transaction->id(), id(), keyRange, WebIDBCallbacksImpl::create(request).leakPtr());    return request;}