[IndexedDB] Adding async tracing for renderer calls.

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 84 matching lines @@
   if (!wrapper.IsEmpty()) {
     V8PrivateProperty::GetIDBCursorRequest(isolate).Set(
         wrapper, ToV8(request_.Get(), wrapper, isolate));
   }
   return wrapper;
 }
 
 IDBRequest* IDBCursor::update(ScriptState* script_state,
                               const ScriptValue& value,
                               ExceptionState& exception_state) {
-  IDB_TRACE("IDBCursor::update");
-
+  IDB_TRACE("IDBCursor::updateCall");
   if (!transaction_->IsActive()) {
     exception_state.ThrowDOMException(kTransactionInactiveError,
                                       transaction_->InactiveErrorMessage());
     return nullptr;
   }
   if (transaction_->IsReadOnly()) {
     exception_state.ThrowDOMException(
         kReadOnlyError,
         "The record may not be updated inside a read-only transaction.");
     return nullptr;
@@ skipping 14 matching lines @@
     return nullptr;
   }
 
   IDBObjectStore* object_store = EffectiveObjectStore();
   return object_store->put(script_state, kWebIDBPutModeCursorUpdate,
                            IDBAny::Create(this), value, primary_key_,
                            exception_state);
 }
 
 void IDBCursor::advance(unsigned count, ExceptionState& exception_state) {
-  IDB_TRACE("IDBCursor::advance");
+  IDB_TRACE("IDBCursor::advanceCall");
+  auto metrics = WTF::MakeUnique<IDBRequest::ScopedMetricsTracker>(
+      nullptr, "IDBCursor::advance", this);
   if (!count) {
     exception_state.ThrowTypeError(
         "A count argument with value 0 (zero) was supplied, must be greater "
         "than 0.");
     return;
   }
   if (!transaction_->IsActive()) {
     exception_state.ThrowDOMException(kTransactionInactiveError,
                                       transaction_->InactiveErrorMessage());
     return;
   }
   if (IsDeleted()) {
     exception_state.ThrowDOMException(kInvalidStateError,
                                       IDBDatabase::kSourceDeletedErrorMessage);
     return;
   }
   if (!got_value_) {
     exception_state.ThrowDOMException(kInvalidStateError,
                                       IDBDatabase::kNoValueErrorMessage);
     return;
   }
 
   request_->SetPendingCursor(this);
+  request_->AssignNewMetrics(std::move(metrics));
   got_value_ = false;
   backend_->Advance(count, request_->CreateWebCallbacks().release());
 }
 
 void IDBCursor::continueFunction(ScriptState* script_state,
                                  const ScriptValue& key_value,
                                  ExceptionState& exception_state) {
-  IDB_TRACE("IDBCursor::continue");
+  IDB_TRACE("IDBCursor::continueCall");
+  auto metrics = WTF::MakeUnique<IDBRequest::ScopedMetricsTracker>(
+      nullptr, "IDBCursor::continue", this);
 
   if (!transaction_->IsActive()) {
     exception_state.ThrowDOMException(kTransactionInactiveError,
                                       transaction_->InactiveErrorMessage());
     return;
   }
   if (!got_value_) {
     exception_state.ThrowDOMException(kInvalidStateError,
                                       IDBDatabase::kNoValueErrorMessage);
     return;
   }
   if (IsDeleted()) {
     exception_state.ThrowDOMException(kInvalidStateError,
                                       IDBDatabase::kSourceDeletedErrorMessage);
     return;
   }
 
   IDBKey* key = key_value.IsUndefined() || key_value.IsNull()
                     ? nullptr
                     : ScriptValue::To<IDBKey*>(script_state->GetIsolate(),
                                                key_value, exception_state);
   if (exception_state.HadException())
     return;
   if (key && !key->IsValid()) {
     exception_state.ThrowDOMException(kDataError,
                                       IDBDatabase::kNotValidKeyErrorMessage);
     return;
   }
+  request_->AssignNewMetrics(std::move(metrics));
   Continue(key, nullptr, exception_state);
 }
 
 void IDBCursor::continuePrimaryKey(ScriptState* script_state,
                                    const ScriptValue& key_value,
                                    const ScriptValue& primary_key_value,
                                    ExceptionState& exception_state) {
-  IDB_TRACE("IDBCursor::continuePrimaryKey");
+  IDB_TRACE("IDBCursor::continuePrimaryKeyCall");
+  auto metrics = WTF::MakeUnique<IDBRequest::ScopedMetricsTracker>(
+      nullptr, "IDBCursor::continuePrimaryKey", this);
 
   if (!transaction_->IsActive()) {
     exception_state.ThrowDOMException(kTransactionInactiveError,
                                       transaction_->InactiveErrorMessage());
     return;
   }
 
   if (IsDeleted()) {
     exception_state.ThrowDOMException(kInvalidStateError,
                                       IDBDatabase::kSourceDeletedErrorMessage);
@@ skipping 32 matching lines @@
   IDBKey* primary_key = ScriptValue::To<IDBKey*>(
       script_state->GetIsolate(), primary_key_value, exception_state);
   if (exception_state.HadException())
     return;
   if (!primary_key->IsValid()) {
     exception_state.ThrowDOMException(kDataError,
                                       IDBDatabase::kNotValidKeyErrorMessage);
     return;
   }
 
+  request_->AssignNewMetrics(std::move(metrics));
   Continue(key, primary_key, exception_state);
 }
 
 void IDBCursor::Continue(IDBKey* key,
                          IDBKey* primary_key,
                          ExceptionState& exception_state) {
   DCHECK(transaction_->IsActive());
   DCHECK(got_value_);
   DCHECK(!IsDeleted());
   DCHECK(!primary_key || (key && primary_key));
@@ skipping 29 matching lines @@
   // means the callback will be on the original context openCursor was called
   // on. Is this right?
   request_->SetPendingCursor(this);
   got_value_ = false;
   backend_->ContinueFunction(key, primary_key,
                              request_->CreateWebCallbacks().release());
 }
 
 IDBRequest* IDBCursor::deleteFunction(ScriptState* script_state,
                                       ExceptionState& exception_state) {
-  IDB_TRACE("IDBCursor::delete");
+  IDB_TRACE("IDBCursor::deleteCall");
+  auto metrics = WTF::MakeUnique<IDBRequest::ScopedMetricsTracker>(
+      nullptr, "IDBCursor::delete", this);
   if (!transaction_->IsActive()) {
     exception_state.ThrowDOMException(kTransactionInactiveError,
                                       transaction_->InactiveErrorMessage());
     return nullptr;
   }
   if (transaction_->IsReadOnly()) {
     exception_state.ThrowDOMException(
         kReadOnlyError,
         "The record may not be deleted inside a read-only transaction.");
     return nullptr;
@@ skipping 15 matching lines @@
   }
   if (!transaction_->BackendDB()) {
     exception_state.ThrowDOMException(kInvalidStateError,
                                       IDBDatabase::kDatabaseClosedErrorMessage);
     return nullptr;
   }
 
   IDBKeyRange* key_range = IDBKeyRange::only(primary_key_, exception_state);
   DCHECK(!exception_state.HadException());
 
-  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));
   transaction_->BackendDB()->DeleteRange(
       transaction_->Id(), EffectiveObjectStore()->Id(), key_range,
       request->CreateWebCallbacks().release());
   return request;
 }
 
 void IDBCursor::PostSuccessHandlerCallback() {
   if (backend_)
     backend_->PostSuccessHandlerCallback();
 }
@@ skipping 100 matching lines @@
     case kWebIDBCursorDirectionPrevNoDuplicate:
       return IndexedDBNames::prevunique;
 
     default:
       NOTREACHED();
       return IndexedDBNames::next;
   }
 }
 
 }  // namespace blink