[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");

[pwnall, 2017/05/25 23:04:25]

The Call suffixes don't seem very informative to me. How about something like
RequestSetup / RequestCreation, or just Setup if length matters.

[dmurph, 2017/05/31 19:26:25]

Done.

   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");
+  IDBRequest::AsyncTraceState metrics("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");
+  IDBRequest::AsyncTraceState metrics("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;
   }
-  Continue(key, nullptr, exception_state);
+  Continue(key, nullptr, exception_state, std::move(metrics));
 }
 
 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");
+  IDBRequest::AsyncTraceState metrics("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;
   }
 
-  Continue(key, primary_key, exception_state);
+  Continue(key, primary_key, exception_state, std::move(metrics));
 }
 
 void IDBCursor::Continue(IDBKey* key,
                          IDBKey* primary_key,
-                         ExceptionState& exception_state) {
+                         ExceptionState& exception_state,
+                         IDBRequest::AsyncTraceState metrics) {
   DCHECK(transaction_->IsActive());
   DCHECK(got_value_);
   DCHECK(!IsDeleted());
   DCHECK(!primary_key || (key && primary_key));
 
   if (key) {
     DCHECK(key_);
     if (direction_ == kWebIDBCursorDirectionNext ||
         direction_ == kWebIDBCursorDirectionNextNoDuplicate) {
       const bool ok =
@@ skipping 16 matching lines @@
                                           "equal to this cursor's position.");
         return;
       }
     }
   }
 
   // FIXME: We're not using the context from when continue was called, which
   // means the callback will be on the original context openCursor was called
   // on. Is this right?
   request_->SetPendingCursor(this);
+  request_->AssignNewMetrics(std::move(metrics));
   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");
+  IDBRequest::AsyncTraceState metrics("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