[IndexedDB] Adding async tracing for renderer calls.

third_party/WebKit/Source/modules/indexeddb/IDBRequest.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/ExceptionCode.h"
 #include "core/dom/ExecutionContext.h"
 #include "core/events/EventQueue.h"
 #include "modules/IndexedDBNames.h"
 #include "modules/indexeddb/IDBCursorWithValue.h"
 #include "modules/indexeddb/IDBDatabase.h"
 #include "modules/indexeddb/IDBEventDispatcher.h"
 #include "modules/indexeddb/IDBTracing.h"
 #include "modules/indexeddb/IDBValue.h"
 #include "modules/indexeddb/WebIDBCallbacksImpl.h"
+#include "platform/Histogram.h"
 #include "platform/SharedBuffer.h"
 #include "public/platform/WebBlobInfo.h"
 
 using blink::WebIDBCursor;
 
 namespace blink {
 
-IDBRequest* IDBRequest::Create(ScriptState* script_state,
-                               IDBAny* source,
-                               IDBTransaction* transaction) {
-  IDBRequest* request = new IDBRequest(script_state, source, transaction);
+IDBRequest::ScopedMetricsTracker::ScopedMetricsTracker(const char* uma_name,
+                                                       const char* tracing_name,
+                                                       void* id)
+    : uma_name_(uma_name),
+      tracing_name_(tracing_name),
+      id_(id),
+      start_(uma_name_ ? WTF::TimeTicks::Now() : WTF::TimeTicks()) {
+  if (tracing_name_)
+    TRACE_EVENT_ASYNC_BEGIN0("IndexedDB", tracing_name_, id);
+}
+
+IDBRequest::ScopedMetricsTracker::~ScopedMetricsTracker() {
+  if (tracing_name_)
+    TRACE_EVENT_ASYNC_END0("IndexedDB", tracing_name_, id_);
+}
+
+void IDBRequest::ScopedMetricsTracker::RecordUMAMetrics() const {
+  if (uma_name_)
+    UMA_HISTOGRAM_MEDIUM_TIMES(uma_name_, WTF::TimeTicks::Now() - start_);

[pwnall, 2017/05/18 22:14:32]

Does this not record UMA data?

[dmurph, 2017/05/18 23:51:15]

not anymore :P

+}
+
+IDBRequest* IDBRequest::Create(
+    ScriptState* script_state,
+    IDBAny* source,
+    IDBTransaction* transaction,
+    std::unique_ptr<IDBRequest::ScopedMetricsTracker> metrics) {
+  IDBRequest* request =
+      new IDBRequest(script_state, source, transaction, std::move(metrics));
   request->SuspendIfNeeded();
   // Requests associated with IDBFactory (open/deleteDatabase/getDatabaseNames)
   // are not associated with transactions.
   if (transaction)
     transaction->RegisterRequest(request);
   return request;
 }
 
 IDBRequest::IDBRequest(ScriptState* script_state,
                        IDBAny* source,
-                       IDBTransaction* transaction)
+                       IDBTransaction* transaction,
+                       std::unique_ptr<ScopedMetricsTracker> metrics)
     : SuspendableObject(ExecutionContext::From(script_state)),
       transaction_(transaction),
       isolate_(script_state->GetIsolate()),
-      source_(source) {}
+      source_(source),
+      metrics_(std::move(metrics)) {}
 
 IDBRequest::~IDBRequest() {
   DCHECK(ready_state_ == DONE || ready_state_ == kEarlyDeath ||
          !GetExecutionContext());
 }
 
 DEFINE_TRACE(IDBRequest) {
   visitor->Trace(transaction_);
   visitor->Trace(source_);
   visitor->Trace(result_);
@@ skipping 159 matching lines @@
 void IDBRequest::EnqueueResponse(DOMException* error) {
   IDB_TRACE("IDBRequest::onError()");
   ClearPutOperationBlobs();
   if (!ShouldEnqueueEvent())
     return;
 
   error_ = error;
   SetResult(IDBAny::CreateUndefined());
   pending_cursor_.Clear();
   EnqueueEvent(Event::CreateCancelableBubble(EventTypeNames::error));
+  MaybeRecordMetrics();
 }
 
 void IDBRequest::EnqueueResponse(const Vector<String>& string_list) {
   IDB_TRACE("IDBRequest::onSuccess(StringList)");
   if (!ShouldEnqueueEvent())
     return;
 
   DOMStringList* dom_string_list = DOMStringList::Create();
   for (size_t i = 0; i < string_list.size(); ++i)
     dom_string_list->Append(string_list[i]);
   EnqueueResultInternal(IDBAny::Create(dom_string_list));
+  MaybeRecordMetrics();
 }
 
 void IDBRequest::EnqueueResponse(std::unique_ptr<WebIDBCursor> backend,
                                  IDBKey* key,
                                  IDBKey* primary_key,
                                  PassRefPtr<IDBValue> value) {
   IDB_TRACE("IDBRequest::onSuccess(IDBCursor)");
   if (!ShouldEnqueueEvent())
     return;
 
   DCHECK(!pending_cursor_);
   IDBCursor* cursor = nullptr;
   switch (cursor_type_) {
     case IndexedDB::kCursorKeyOnly:
       cursor = IDBCursor::Create(std::move(backend), cursor_direction_, this,
                                  source_.Get(), transaction_.Get());
       break;
     case IndexedDB::kCursorKeyAndValue:
       cursor =
           IDBCursorWithValue::Create(std::move(backend), cursor_direction_,
                                      this, source_.Get(), transaction_.Get());
       break;
     default:
       NOTREACHED();
   }
   SetResultCursor(cursor, key, primary_key, std::move(value));
+  MaybeRecordMetrics();
 }
 
 void IDBRequest::EnqueueResponse(IDBKey* idb_key) {
   IDB_TRACE("IDBRequest::onSuccess(IDBKey)");
   ClearPutOperationBlobs();
   if (!ShouldEnqueueEvent())
     return;
 
   if (idb_key && idb_key->IsValid())
     EnqueueResultInternal(IDBAny::Create(idb_key));
   else
     EnqueueResultInternal(IDBAny::CreateUndefined());
+  MaybeRecordMetrics();
 }
 
 void IDBRequest::EnqueueResponse(const Vector<RefPtr<IDBValue>>& values) {
   IDB_TRACE("IDBRequest::onSuccess([IDBValue])");
   if (!ShouldEnqueueEvent())
     return;
 
   AckReceivedBlobs(values);
   EnqueueResultInternal(IDBAny::Create(values));
+  MaybeRecordMetrics();
 }
 
 #if DCHECK_IS_ON()
 static IDBObjectStore* EffectiveObjectStore(IDBAny* source) {
   if (source->GetType() == IDBAny::kIDBObjectStoreType)
     return source->IdbObjectStore();
   if (source->GetType() == IDBAny::kIDBIndexType)
     return source->IdbIndex()->objectStore();
 
   NOTREACHED();
@@ skipping 16 matching lines @@
     pending_cursor_->Close();
     pending_cursor_.Clear();
   }
 
 #if DCHECK_IS_ON()
   DCHECK(!value->PrimaryKey() ||
          value->KeyPath() == EffectiveObjectStore(source_)->IdbKeyPath());
 #endif
 
   EnqueueResultInternal(IDBAny::Create(value.Release()));
+  MaybeRecordMetrics();
 }
 
 void IDBRequest::EnqueueResponse(int64_t value) {
   IDB_TRACE("IDBRequest::onSuccess(int64_t)");
   if (!ShouldEnqueueEvent())
     return;
   EnqueueResultInternal(IDBAny::Create(value));
+  MaybeRecordMetrics();
 }
 
 void IDBRequest::EnqueueResponse() {
   IDB_TRACE("IDBRequest::onSuccess()");
   if (!ShouldEnqueueEvent())
     return;
   EnqueueResultInternal(IDBAny::CreateUndefined());
+  MaybeRecordMetrics();
 }
 
 void IDBRequest::EnqueueResultInternal(IDBAny* result) {
   DCHECK(GetExecutionContext());
   DCHECK(!pending_cursor_);
   DCHECK(transit_blob_handles_.IsEmpty());
   SetResult(result);
   EnqueueEvent(Event::Create(EventTypeNames::success));
 }
 
 void IDBRequest::SetResult(IDBAny* result) {
   result_ = result;
   result_dirty_ = true;
 }
 
 void IDBRequest::EnqueueResponse(IDBKey* key,
                                  IDBKey* primary_key,
                                  PassRefPtr<IDBValue> value) {
   IDB_TRACE("IDBRequest::onSuccess(key, primaryKey, value)");
   if (!ShouldEnqueueEvent())
     return;
 
   DCHECK(pending_cursor_);
   SetResultCursor(pending_cursor_.Release(), key, primary_key,
                   std::move(value));
+  MaybeRecordMetrics();
 }
 
 bool IDBRequest::HasPendingActivity() const {
   // FIXME: In an ideal world, we should return true as long as anyone has a or
   //        can get a handle to us and we have event listeners. This is order to
   //        handle user generated events properly.
   return has_pending_activity_ && GetExecutionContext();
 }
 
 void IDBRequest::ContextDestroyed(ExecutionContext*) {
@@ skipping 161 matching lines @@
 }
 
 void IDBRequest::DequeueEvent(Event* event) {
   for (size_t i = 0; i < enqueued_events_.size(); ++i) {
     if (enqueued_events_[i].Get() == event)
       enqueued_events_.erase(i);
   }
 }
 
 }  // namespace blink