[IndexedDB] Adding async tracing for renderer calls.

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 97 matching lines @@
 
   // An index's metadata will only get reverted if the index was in the
   // database when the versionchange transaction started.
   deleted_ = false;
 }
 
 IDBRequest* IDBIndex::openCursor(ScriptState* script_state,
                                  const ScriptValue& range,
                                  const String& direction_string,
                                  ExceptionState& exception_state) {
-  IDB_TRACE("IDBIndex::openCursor");
+  IDB_TRACE("IDBIndex::openCursorRequestSetup");
+  IDBRequest::AsyncTraceState metrics("IDBIndex::openCursor", this);
   if (IsDeleted()) {
     exception_state.ThrowDOMException(kInvalidStateError,
                                       IDBDatabase::kIndexDeletedErrorMessage);
     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);
+  return openCursor(script_state, key_range, direction, std::move(metrics));
 }
 
 IDBRequest* IDBIndex::openCursor(ScriptState* script_state,
                                  IDBKeyRange* key_range,
-                                 WebIDBCursorDirection direction) {
-  IDBRequest* request = IDBRequest::Create(script_state, IDBAny::Create(this),
-                                           transaction_.Get());
+                                 WebIDBCursorDirection direction,
+                                 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(), object_store_->Id(), Id(),
                           key_range, direction, false, kWebIDBTaskTypeNormal,
                           request->CreateWebCallbacks().release());
   return request;
 }
 
 IDBRequest* IDBIndex::count(ScriptState* script_state,
                             const ScriptValue& range,
                             ExceptionState& exception_state) {
-  IDB_TRACE("IDBIndex::count");
+  IDB_TRACE("IDBIndex::countRequestSetup");
+  IDBRequest::AsyncTraceState metrics("IDBIndex::count", this);
   if (IsDeleted()) {
     exception_state.ThrowDOMException(kInvalidStateError,
                                       IDBDatabase::kIndexDeletedErrorMessage);
     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(), object_store_->Id(), Id(), key_range,
                      request->CreateWebCallbacks().release());
   return request;
 }
 
 IDBRequest* IDBIndex::openKeyCursor(ScriptState* script_state,
                                     const ScriptValue& range,
                                     const String& direction_string,
                                     ExceptionState& exception_state) {
-  IDB_TRACE("IDBIndex::openKeyCursor");
+  IDB_TRACE("IDBIndex::openKeyCursorRequestSetup");
+  IDBRequest::AsyncTraceState metrics("IDBIndex::openKeyCursor", this);
   if (IsDeleted()) {
     exception_state.ThrowDOMException(kInvalidStateError,
                                       IDBDatabase::kIndexDeletedErrorMessage);
     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(), object_store_->Id(), Id(),
                           key_range, direction, true, kWebIDBTaskTypeNormal,
                           request->CreateWebCallbacks().release());
   return request;
 }
 
 IDBRequest* IDBIndex::get(ScriptState* script_state,
                           const ScriptValue& key,
                           ExceptionState& exception_state) {
-  IDB_TRACE("IDBIndex::get");
+  IDB_TRACE("IDBIndex::getRequestSetup");
   return GetInternal(script_state, key, exception_state, false);
 }
 
 IDBRequest* IDBIndex::getAll(ScriptState* script_state,
                              const ScriptValue& range,
                              ExceptionState& exception_state) {
   return getAll(script_state, range, std::numeric_limits<uint32_t>::max(),
                 exception_state);
 }
 
 IDBRequest* IDBIndex::getAll(ScriptState* script_state,
                              const ScriptValue& range,
                              unsigned long max_count,
                              ExceptionState& exception_state) {
-  IDB_TRACE("IDBIndex::getAll");
+  IDB_TRACE("IDBIndex::getAllRequestSetup");
   return GetAllInternal(script_state, range, max_count, exception_state, false);
 }
 
 IDBRequest* IDBIndex::getAllKeys(ScriptState* script_state,
                                  const ScriptValue& range,
                                  ExceptionState& exception_state) {
   return getAllKeys(script_state, range, std::numeric_limits<uint32_t>::max(),
                     exception_state);
 }
 
 IDBRequest* IDBIndex::getAllKeys(ScriptState* script_state,
                                  const ScriptValue& range,
                                  uint32_t max_count,
                                  ExceptionState& exception_state) {
-  IDB_TRACE("IDBIndex::getAllKeys");
+  IDB_TRACE("IDBIndex::getAllKeysRequestSetup");
   return GetAllInternal(script_state, range, max_count, exception_state,
                         /*key_only=*/true);
 }
 
 IDBRequest* IDBIndex::getKey(ScriptState* script_state,
                              const ScriptValue& key,
                              ExceptionState& exception_state) {
-  IDB_TRACE("IDBIndex::getKey");
+  IDB_TRACE("IDBIndex::getKeyRequestSetup");
   return GetInternal(script_state, key, exception_state, true);
 }
 
 IDBRequest* IDBIndex::GetInternal(ScriptState* script_state,
                                   const ScriptValue& key,
                                   ExceptionState& exception_state,
                                   bool key_only) {
+  IDBRequest::AsyncTraceState metrics(
+      key_only ? "IDBIndex::getKey" : "IDBIndex::get", this);
   if (IsDeleted()) {
     exception_state.ThrowDOMException(kInvalidStateError,
                                       IDBDatabase::kIndexDeletedErrorMessage);
     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(), object_store_->Id(), Id(), key_range,
                    key_only, request->CreateWebCallbacks().release());
   return request;
 }
 
 IDBRequest* IDBIndex::GetAllInternal(ScriptState* script_state,
                                      const ScriptValue& range,
                                      unsigned long max_count,
                                      ExceptionState& exception_state,
                                      bool key_only) {
+  IDBRequest::AsyncTraceState metrics(
+      key_only ? "IDBIndex::getAllKeys" : "IDBIndex::getAll", this);
   if (!max_count)
     max_count = std::numeric_limits<uint32_t>::max();
 
   if (IsDeleted()) {
     exception_state.ThrowDOMException(kInvalidStateError,
                                       IDBDatabase::kIndexDeletedErrorMessage);
     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()->GetAll(transaction_->Id(), object_store_->Id(), Id(), key_range,
                       max_count, key_only,
                       request->CreateWebCallbacks().release());
   return request;
 }
 
 WebIDBDatabase* IDBIndex::BackendDB() const {
   return transaction_->BackendDB();
 }
 
 }  // namespace blink