[IndexedDB] Adding async tracing for renderer calls.

third_party/WebKit/Source/modules/indexeddb/IDBObjectStore.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 26 matching lines @@
 #include "core/dom/ExecutionContext.h"
 #include "modules/indexeddb/IDBAny.h"
 #include "modules/indexeddb/IDBCursorWithValue.h"
 #include "modules/indexeddb/IDBDatabase.h"
 #include "modules/indexeddb/IDBKeyPath.h"
 #include "modules/indexeddb/IDBTracing.h"
 #include "modules/indexeddb/IDBValueWrapping.h"
 #include "platform/Histogram.h"
 #include "platform/SharedBuffer.h"
 #include "platform/bindings/ScriptState.h"
+#include "platform/wtf/PtrUtil.h"
 #include "platform/wtf/RefPtr.h"
 #include "public/platform/WebBlobInfo.h"
 #include "public/platform/WebData.h"
 #include "public/platform/WebVector.h"
 #include "public/platform/modules/indexeddb/WebIDBKey.h"
 #include "public/platform/modules/indexeddb/WebIDBKeyRange.h"
 #include "v8/include/v8.h"
 
 using blink::WebBlobInfo;
 using blink::WebIDBCallbacks;
@@ skipping 65 matching lines @@
   DOMStringList* index_names = DOMStringList::Create();
   for (const auto& it : Metadata().indexes)
     index_names->Append(it.value->name);
   index_names->Sort();
   return index_names;
 }
 
 IDBRequest* IDBObjectStore::get(ScriptState* script_state,
                                 const ScriptValue& key,
                                 ExceptionState& exception_state) {
-  IDB_TRACE("IDBObjectStore::get");
+  IDB_TRACE("IDBObjectStore::getRequestSetup");
+  IDBRequest::AsyncTraceState metrics("IDBObjectStore::get", this);
   if (IsDeleted()) {
     exception_state.ThrowDOMException(
         kInvalidStateError, IDBDatabase::kObjectStoreDeletedErrorMessage);
     return nullptr;
   }
   if (!transaction_->IsActive()) {
     exception_state.ThrowDOMException(kTransactionInactiveError,
                                       transaction_->InactiveErrorMessage());
     return nullptr;
   }
   IDBKeyRange* key_range = IDBKeyRange::FromScriptValue(
       ExecutionContext::From(script_state), key, exception_state);
   if (exception_state.HadException())
     return nullptr;
   if (!key_range) {
     exception_state.ThrowDOMException(
         kDataError, IDBDatabase::kNoKeyOrKeyRangeErrorMessage);
     return nullptr;
   }
   if (!BackendDB()) {
     exception_state.ThrowDOMException(kInvalidStateError,
                                       IDBDatabase::kDatabaseClosedErrorMessage);
     return nullptr;
   }
 
-  IDBRequest* request = IDBRequest::Create(script_state, IDBAny::Create(this),
-                                           transaction_.Get());
+  IDBRequest* request =
+      IDBRequest::Create(script_state, IDBAny::Create(this), transaction_.Get(),
+                         std::move(metrics));
   BackendDB()->Get(transaction_->Id(), Id(), IDBIndexMetadata::kInvalidId,
                    key_range, /*key_only=*/false,
                    request->CreateWebCallbacks().release());
   return request;
 }
 
 IDBRequest* IDBObjectStore::getKey(ScriptState* script_state,
                                    const ScriptValue& key,
                                    ExceptionState& exception_state) {
-  IDB_TRACE("IDBObjectStore::getKey");
+  IDB_TRACE("IDBObjectStore::getKeyRequestSetup");
+  IDBRequest::AsyncTraceState metrics("IDBObjectStore::getKey", this);
   if (IsDeleted()) {
     exception_state.ThrowDOMException(
         kInvalidStateError, IDBDatabase::kObjectStoreDeletedErrorMessage);
     return nullptr;
   }
   if (!transaction_->IsActive()) {
     exception_state.ThrowDOMException(kTransactionInactiveError,
                                       transaction_->InactiveErrorMessage());
     return nullptr;
   }
   IDBKeyRange* key_range = IDBKeyRange::FromScriptValue(
       ExecutionContext::From(script_state), key, exception_state);
   if (exception_state.HadException())
     return nullptr;
   if (!key_range) {
     exception_state.ThrowDOMException(
         kDataError, IDBDatabase::kNoKeyOrKeyRangeErrorMessage);
     return nullptr;
   }
   if (!BackendDB()) {
     exception_state.ThrowDOMException(kInvalidStateError,
                                       IDBDatabase::kDatabaseClosedErrorMessage);
     return nullptr;
   }
 
-  IDBRequest* request = IDBRequest::Create(script_state, IDBAny::Create(this),
-                                           transaction_.Get());
+  IDBRequest* request =
+      IDBRequest::Create(script_state, IDBAny::Create(this), transaction_.Get(),
+                         std::move(metrics));
   BackendDB()->Get(transaction_->Id(), Id(), IDBIndexMetadata::kInvalidId,
                    key_range, /*key_only=*/true,
                    request->CreateWebCallbacks().release());
   return request;
 }
 
 IDBRequest* IDBObjectStore::getAll(ScriptState* script_state,
                                    const ScriptValue& key_range,
                                    ExceptionState& exception_state) {
   return getAll(script_state, key_range, std::numeric_limits<uint32_t>::max(),
                 exception_state);
 }
 
 IDBRequest* IDBObjectStore::getAll(ScriptState* script_state,
                                    const ScriptValue& key_range,
                                    unsigned long max_count,
                                    ExceptionState& exception_state) {
-  IDB_TRACE("IDBObjectStore::getAll");
+  IDB_TRACE("IDBObjectStore::getAllRequestSetup");
+  IDBRequest::AsyncTraceState metrics("IDBObjectStore::getAll", this);
   if (!max_count)
     max_count = std::numeric_limits<uint32_t>::max();
 
   if (IsDeleted()) {
     exception_state.ThrowDOMException(
         kInvalidStateError, IDBDatabase::kObjectStoreDeletedErrorMessage);
     return nullptr;
   }
   if (!transaction_->IsActive()) {
     exception_state.ThrowDOMException(kTransactionInactiveError,
                                       transaction_->InactiveErrorMessage());
     return nullptr;
   }
   IDBKeyRange* range = IDBKeyRange::FromScriptValue(
       ExecutionContext::From(script_state), key_range, exception_state);
   if (exception_state.HadException())
     return nullptr;
   if (!BackendDB()) {
     exception_state.ThrowDOMException(kInvalidStateError,
                                       IDBDatabase::kDatabaseClosedErrorMessage);
     return nullptr;
   }
 
-  IDBRequest* request = IDBRequest::Create(script_state, IDBAny::Create(this),
-                                           transaction_.Get());
+  IDBRequest* request =
+      IDBRequest::Create(script_state, IDBAny::Create(this), transaction_.Get(),
+                         std::move(metrics));
   BackendDB()->GetAll(transaction_->Id(), Id(), IDBIndexMetadata::kInvalidId,
                       range, max_count, false,
                       request->CreateWebCallbacks().release());
   return request;
 }
 
 IDBRequest* IDBObjectStore::getAllKeys(ScriptState* script_state,
                                        const ScriptValue& key_range,
                                        ExceptionState& exception_state) {
   return getAllKeys(script_state, key_range,
                     std::numeric_limits<uint32_t>::max(), exception_state);
 }
 
 IDBRequest* IDBObjectStore::getAllKeys(ScriptState* script_state,
                                        const ScriptValue& key_range,
                                        unsigned long max_count,
                                        ExceptionState& exception_state) {
-  IDB_TRACE("IDBObjectStore::getAll");
+  IDB_TRACE("IDBObjectStore::getAllKeysRequestSetup");
+  IDBRequest::AsyncTraceState metrics("IDBObjectStore::getAllKeys", this);
   if (!max_count)
     max_count = std::numeric_limits<uint32_t>::max();
 
   if (IsDeleted()) {
     exception_state.ThrowDOMException(
         kInvalidStateError, IDBDatabase::kObjectStoreDeletedErrorMessage);
     return nullptr;
   }
   if (!transaction_->IsActive()) {
     exception_state.ThrowDOMException(kTransactionInactiveError,
                                       transaction_->InactiveErrorMessage());
     return nullptr;
   }
   IDBKeyRange* range = IDBKeyRange::FromScriptValue(
       ExecutionContext::From(script_state), key_range, exception_state);
   if (exception_state.HadException())
     return nullptr;
   if (!BackendDB()) {
     exception_state.ThrowDOMException(kInvalidStateError,
                                       IDBDatabase::kDatabaseClosedErrorMessage);
     return nullptr;
   }
 
-  IDBRequest* request = IDBRequest::Create(script_state, IDBAny::Create(this),
-                                           transaction_.Get());
+  IDBRequest* request =
+      IDBRequest::Create(script_state, IDBAny::Create(this), transaction_.Get(),
+                         std::move(metrics));
   BackendDB()->GetAll(transaction_->Id(), Id(), IDBIndexMetadata::kInvalidId,
                       range, max_count, true,
                       request->CreateWebCallbacks().release());
   return request;
 }
 
 static void GenerateIndexKeysForValue(v8::Isolate* isolate,
                                       const IDBIndexMetadata& index_metadata,
                                       const ScriptValue& object_value,
                                       IndexKeys* index_keys) {
@@ skipping 24 matching lines @@
     for (const IDBKey* key : array)
       key_type_histogram.Count(static_cast<int>(key->GetType()));
     index_keys->AppendVector(array);
   }
 }
 
 IDBRequest* IDBObjectStore::add(ScriptState* script_state,
                                 const ScriptValue& value,
                                 const ScriptValue& key,
                                 ExceptionState& exception_state) {
-  IDB_TRACE("IDBObjectStore::add");
+  IDB_TRACE("IDBObjectStore::addRequestSetup");
   return put(script_state, kWebIDBPutModeAddOnly, IDBAny::Create(this), value,
              key, exception_state);
 }
 
 IDBRequest* IDBObjectStore::put(ScriptState* script_state,
                                 const ScriptValue& value,
                                 const ScriptValue& key,
                                 ExceptionState& exception_state) {
-  IDB_TRACE("IDBObjectStore::put");
+  IDB_TRACE("IDBObjectStore::putRequestSetup");
   return put(script_state, kWebIDBPutModeAddOrUpdate, IDBAny::Create(this),
              value, key, exception_state);
 }
 
 IDBRequest* IDBObjectStore::put(ScriptState* script_state,
                                 WebIDBPutMode put_mode,
                                 IDBAny* source,
                                 const ScriptValue& value,
                                 const ScriptValue& key_value,
                                 ExceptionState& exception_state) {
   IDBKey* key = key_value.IsUndefined()
                     ? nullptr
                     : ScriptValue::To<IDBKey*>(script_state->GetIsolate(),
                                                key_value, exception_state);
   if (exception_state.HadException())
     return nullptr;
   return put(script_state, put_mode, source, value, key, exception_state);
 }
 
 IDBRequest* IDBObjectStore::put(ScriptState* script_state,
                                 WebIDBPutMode put_mode,
                                 IDBAny* source,
                                 const ScriptValue& value,
                                 IDBKey* key,
                                 ExceptionState& exception_state) {
+  const char* tracing_name = nullptr;
+  switch (put_mode) {
+    case kWebIDBPutModeAddOrUpdate:
+      tracing_name = "IDBObjectStore::put";
+      break;
+    case kWebIDBPutModeAddOnly:
+      tracing_name = "IDBObjectStore::add";
+      break;
+    case kWebIDBPutModeCursorUpdate:
+      tracing_name = "IDBCursor::update";
+      break;
+  }
+  IDBRequest::AsyncTraceState metrics(tracing_name, this);
   if (IsDeleted()) {
     exception_state.ThrowDOMException(
         kInvalidStateError, IDBDatabase::kObjectStoreDeletedErrorMessage);
     return nullptr;
   }
   if (!transaction_->IsActive()) {
     exception_state.ThrowDOMException(kTransactionInactiveError,
                                       transaction_->InactiveErrorMessage());
     return nullptr;
   }
@@ skipping 116 matching lines @@
   for (const auto& it : Metadata().indexes) {
     if (clone.IsEmpty())
       value_wrapper.Clone(script_state, &clone);
     IndexKeys keys;
     GenerateIndexKeysForValue(script_state->GetIsolate(), *it.value, clone,
                               &keys);
     index_ids.push_back(it.key);
     index_keys.push_back(keys);
   }
 
-  IDBRequest* request =
-      IDBRequest::Create(script_state, source, transaction_.Get());
+  IDBRequest* request = IDBRequest::Create(
+      script_state, source, transaction_.Get(), std::move(metrics));
 
   value_wrapper.ExtractBlobDataHandles(request->transit_blob_handles());
   value_wrapper.WrapIfBiggerThan(IDBValueWrapper::kWrapThreshold);
 
   BackendDB()->Put(
       transaction_->Id(), Id(), WebData(value_wrapper.ExtractWireBytes()),
       value_wrapper.WrappedBlobInfo(), key,
       static_cast<WebIDBPutMode>(put_mode),
       request->CreateWebCallbacks().release(), index_ids, index_keys);
 
   return request;
 }
 
 IDBRequest* IDBObjectStore::deleteFunction(ScriptState* script_state,
                                            const ScriptValue& key,
                                            ExceptionState& exception_state) {
-  IDB_TRACE("IDBObjectStore::delete");
+  IDB_TRACE("IDBObjectStore::deleteRequestSetup");
+  IDBRequest::AsyncTraceState metrics("IDBObjectStore::delete", this);
   if (IsDeleted()) {
     exception_state.ThrowDOMException(
         kInvalidStateError, IDBDatabase::kObjectStoreDeletedErrorMessage);
     return nullptr;
   }
   if (!transaction_->IsActive()) {
     exception_state.ThrowDOMException(kTransactionInactiveError,
                                       transaction_->InactiveErrorMessage());
     return nullptr;
   }
@@ skipping 11 matching lines @@
     exception_state.ThrowDOMException(
         kDataError, IDBDatabase::kNoKeyOrKeyRangeErrorMessage);
     return nullptr;
   }
   if (!BackendDB()) {
     exception_state.ThrowDOMException(kInvalidStateError,
                                       IDBDatabase::kDatabaseClosedErrorMessage);
     return nullptr;
   }
 
-  IDBRequest* request = IDBRequest::Create(script_state, IDBAny::Create(this),
-                                           transaction_.Get());
+  IDBRequest* request =
+      IDBRequest::Create(script_state, IDBAny::Create(this), transaction_.Get(),
+                         std::move(metrics));
   BackendDB()->DeleteRange(transaction_->Id(), Id(), key_range,
                            request->CreateWebCallbacks().release());
   return request;
 }
 
 IDBRequest* IDBObjectStore::clear(ScriptState* script_state,
                                   ExceptionState& exception_state) {
-  IDB_TRACE("IDBObjectStore::clear");
+  IDB_TRACE("IDBObjectStore::clearRequestSetup");
+  IDBRequest::AsyncTraceState metrics("IDBObjectStore::clear", this);
   if (IsDeleted()) {
     exception_state.ThrowDOMException(
         kInvalidStateError, IDBDatabase::kObjectStoreDeletedErrorMessage);
     return nullptr;
   }
   if (!transaction_->IsActive()) {
     exception_state.ThrowDOMException(kTransactionInactiveError,
                                       transaction_->InactiveErrorMessage());
     return nullptr;
   }
   if (transaction_->IsReadOnly()) {
     exception_state.ThrowDOMException(
         kReadOnlyError, IDBDatabase::kTransactionReadOnlyErrorMessage);
     return nullptr;
   }
   if (!BackendDB()) {
     exception_state.ThrowDOMException(kInvalidStateError,
                                       IDBDatabase::kDatabaseClosedErrorMessage);
     return nullptr;
   }
 
-  IDBRequest* request = IDBRequest::Create(script_state, IDBAny::Create(this),
-                                           transaction_.Get());
+  IDBRequest* request =
+      IDBRequest::Create(script_state, IDBAny::Create(this), transaction_.Get(),
+                         std::move(metrics));
   BackendDB()->Clear(transaction_->Id(), Id(),
                      request->CreateWebCallbacks().release());
   return request;
 }
 
 namespace {
 // This class creates the index keys for a given index by extracting
 // them from the SerializedScriptValue, for all the existing values in
 // the object store. It only needs to be kept alive by virtue of being
 // a listener on an IDBRequest object, in the same way that JavaScript
@@ skipping 31 matching lines @@
         object_store_id_(object_store_id),
         index_metadata_(std::move(index_metadata)) {
     DCHECK(index_metadata_.Get());
   }
 
   const IDBIndexMetadata& IndexMetadata() const { return *index_metadata_; }
 
   void handleEvent(ExecutionContext* execution_context, Event* event) override {
     if (!script_state_->ContextIsValid())
       return;
+    IDB_TRACE("IDBObjectStore::IndexPopulator::handleEvent");
 
     DCHECK_EQ(ExecutionContext::From(script_state_.Get()), execution_context);
     DCHECK_EQ(event->type(), EventTypeNames::success);
     EventTarget* target = event->target();
     IDBRequest* request = static_cast<IDBRequest*>(target);
 
     if (!database_->Backend())  // If database is stopped?
       return;
 
     ScriptState::Scope scope(script_state_.Get());
 
     IDBAny* cursor_any = request->ResultAsAny();
     IDBCursorWithValue* cursor = nullptr;
     if (cursor_any->GetType() == IDBAny::kIDBCursorWithValueType)
       cursor = cursor_any->IdbCursorWithValue();
 
     Vector<int64_t> index_ids;
     index_ids.push_back(IndexMetadata().id);
     if (cursor && !cursor->IsDeleted()) {
-      cursor->Continue(nullptr, nullptr, ASSERT_NO_EXCEPTION);
+      cursor->Continue(nullptr, nullptr,
+                       IDBRequest::AsyncTraceState("IDBCursor::continue", this),
+                       ASSERT_NO_EXCEPTION);
 
       IDBKey* primary_key = cursor->IdbPrimaryKey();
       ScriptValue value = cursor->value(script_state_.Get());
 
       IndexKeys index_keys;
       GenerateIndexKeysForValue(script_state_->GetIsolate(), IndexMetadata(),
                                 value, &index_keys);
 
       HeapVector<IndexKeys> index_keys_list;
       index_keys_list.push_back(index_keys);
@@ skipping 16 matching lines @@
   const int64_t object_store_id_;
   RefPtr<const IDBIndexMetadata> index_metadata_;
 };
 }  // namespace
 
 IDBIndex* IDBObjectStore::createIndex(ScriptState* script_state,
                                       const String& name,
                                       const IDBKeyPath& key_path,
                                       const IDBIndexParameters& options,
                                       ExceptionState& exception_state) {
-  IDB_TRACE("IDBObjectStore::createIndex");
+  IDB_TRACE("IDBObjectStore::createIndexRequestSetup");
+  IDBRequest::AsyncTraceState metrics("IDBObjectStore::createIndex", this);
   if (!transaction_->IsVersionChange()) {
     exception_state.ThrowDOMException(
         kInvalidStateError,
         IDBDatabase::kNotVersionChangeTransactionErrorMessage);
     return nullptr;
   }
   if (IsDeleted()) {
     exception_state.ThrowDOMException(
         kInvalidStateError, IDBDatabase::kObjectStoreDeletedErrorMessage);
     return nullptr;
@@ skipping 37 matching lines @@
   IDBIndex* index = IDBIndex::Create(index_metadata, this, transaction_.Get());
   index_map_.Set(name, index);
   metadata_->indexes.Set(index_id, index_metadata);
 
   DCHECK(!exception_state.HadException());
   if (exception_state.HadException())
     return nullptr;
 
   IDBRequest* index_request =
       openCursor(script_state, nullptr, kWebIDBCursorDirectionNext,
-                 kWebIDBTaskTypePreemptive);
+                 kWebIDBTaskTypePreemptive, std::move(metrics));
   index_request->PreventPropagation();
 
   // This is kept alive by being the success handler of the request, which is in
   // turn kept alive by the owning transaction.
   IndexPopulator* index_populator = IndexPopulator::Create(
       script_state, transaction()->db(), transaction_->Id(), Id(),
       std::move(index_metadata));
   index_request->setOnsuccess(index_populator);
   return index;
 }
@@ skipping 71 matching lines @@
     transaction_->IndexDeleted(it->value);
     it->value->MarkDeleted();
     index_map_.erase(name);
   }
 }
 
 IDBRequest* IDBObjectStore::openCursor(ScriptState* script_state,
                                        const ScriptValue& range,
                                        const String& direction_string,
                                        ExceptionState& exception_state) {
-  IDB_TRACE("IDBObjectStore::openCursor");
+  IDB_TRACE("IDBObjectStore::openCursorRequestSetup");
+  IDBRequest::AsyncTraceState metrics("IDBObjectStore::openCursor", this);
   if (IsDeleted()) {
     exception_state.ThrowDOMException(
         kInvalidStateError, IDBDatabase::kObjectStoreDeletedErrorMessage);
     return nullptr;
   }
   if (!transaction_->IsActive()) {
     exception_state.ThrowDOMException(kTransactionInactiveError,
                                       transaction_->InactiveErrorMessage());
     return nullptr;
   }
 
   WebIDBCursorDirection direction =
       IDBCursor::StringToDirection(direction_string);
   IDBKeyRange* key_range = IDBKeyRange::FromScriptValue(
       ExecutionContext::From(script_state), range, exception_state);
   if (exception_state.HadException())
     return nullptr;
 
   if (!BackendDB()) {
     exception_state.ThrowDOMException(kInvalidStateError,
                                       IDBDatabase::kDatabaseClosedErrorMessage);
     return nullptr;
   }
 
-  return openCursor(script_state, key_range, direction, kWebIDBTaskTypeNormal);
+  return openCursor(script_state, key_range, direction, kWebIDBTaskTypeNormal,
+                    std::move(metrics));
 }
 
 IDBRequest* IDBObjectStore::openCursor(ScriptState* script_state,
                                        IDBKeyRange* range,
                                        WebIDBCursorDirection direction,
-                                       WebIDBTaskType task_type) {
-  IDBRequest* request = IDBRequest::Create(script_state, IDBAny::Create(this),
-                                           transaction_.Get());
+                                       WebIDBTaskType task_type,
+                                       IDBRequest::AsyncTraceState metrics) {
+  IDBRequest* request =
+      IDBRequest::Create(script_state, IDBAny::Create(this), transaction_.Get(),
+                         std::move(metrics));
   request->SetCursorDetails(IndexedDB::kCursorKeyAndValue, direction);
 
   BackendDB()->OpenCursor(transaction_->Id(), Id(),
                           IDBIndexMetadata::kInvalidId, range, direction, false,
                           task_type, request->CreateWebCallbacks().release());
   return request;
 }
 
 IDBRequest* IDBObjectStore::openKeyCursor(ScriptState* script_state,
                                           const ScriptValue& range,
                                           const String& direction_string,
                                           ExceptionState& exception_state) {
-  IDB_TRACE("IDBObjectStore::openKeyCursor");
+  IDB_TRACE("IDBObjectStore::openKeyCursorRequestSetup");
+  IDBRequest::AsyncTraceState metrics("IDBObjectStore::openKeyCursor", this);
   if (IsDeleted()) {
     exception_state.ThrowDOMException(
         kInvalidStateError, IDBDatabase::kObjectStoreDeletedErrorMessage);
     return nullptr;
   }
   if (!transaction_->IsActive()) {
     exception_state.ThrowDOMException(kTransactionInactiveError,
                                       transaction_->InactiveErrorMessage());
     return nullptr;
   }
 
   WebIDBCursorDirection direction =
       IDBCursor::StringToDirection(direction_string);
   IDBKeyRange* key_range = IDBKeyRange::FromScriptValue(
       ExecutionContext::From(script_state), range, exception_state);
   if (exception_state.HadException())
     return nullptr;
 
   if (!BackendDB()) {
     exception_state.ThrowDOMException(kInvalidStateError,
                                       IDBDatabase::kDatabaseClosedErrorMessage);
     return nullptr;
   }
 
-  IDBRequest* request = IDBRequest::Create(script_state, IDBAny::Create(this),
-                                           transaction_.Get());
+  IDBRequest* request =
+      IDBRequest::Create(script_state, IDBAny::Create(this), transaction_.Get(),
+                         std::move(metrics));
   request->SetCursorDetails(IndexedDB::kCursorKeyOnly, direction);
 
   BackendDB()->OpenCursor(transaction_->Id(), Id(),
                           IDBIndexMetadata::kInvalidId, key_range, direction,
                           true, kWebIDBTaskTypeNormal,
                           request->CreateWebCallbacks().release());
   return request;
 }
 
 IDBRequest* IDBObjectStore::count(ScriptState* script_state,
                                   const ScriptValue& range,
                                   ExceptionState& exception_state) {
-  IDB_TRACE("IDBObjectStore::count");
+  IDB_TRACE("IDBObjectStore::countRequestSetup");
+  IDBRequest::AsyncTraceState metrics("IDBObjectStore::count", this);
   if (IsDeleted()) {
     exception_state.ThrowDOMException(
         kInvalidStateError, IDBDatabase::kObjectStoreDeletedErrorMessage);
     return nullptr;
   }
   if (!transaction_->IsActive()) {
     exception_state.ThrowDOMException(kTransactionInactiveError,
                                       transaction_->InactiveErrorMessage());
     return nullptr;
   }
 
   IDBKeyRange* key_range = IDBKeyRange::FromScriptValue(
       ExecutionContext::From(script_state), range, exception_state);
   if (exception_state.HadException())
     return nullptr;
 
   if (!BackendDB()) {
     exception_state.ThrowDOMException(kInvalidStateError,
                                       IDBDatabase::kDatabaseClosedErrorMessage);
     return nullptr;
   }
 
-  IDBRequest* request = IDBRequest::Create(script_state, IDBAny::Create(this),
-                                           transaction_.Get());
+  IDBRequest* request =
+      IDBRequest::Create(script_state, IDBAny::Create(this), transaction_.Get(),
+                         std::move(metrics));
   BackendDB()->Count(transaction_->Id(), Id(), IDBIndexMetadata::kInvalidId,
                      key_range, request->CreateWebCallbacks().release());
   return request;
 }
 
 void IDBObjectStore::MarkDeleted() {
   DCHECK(transaction_->IsVersionChange())
       << "An object store got deleted outside a versionchange transaction.";
 
   deleted_ = true;
@@ skipping 91 matching lines @@
     }
   }
   return IDBIndexMetadata::kInvalidId;
 }
 
 WebIDBDatabase* IDBObjectStore::BackendDB() const {
   return transaction_->BackendDB();
 }
 
 }  // namespace blink