[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 30 matching lines @@
 #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/IDBRequestQueueItem.h"
 #include "modules/indexeddb/IDBTracing.h"
 #include "modules/indexeddb/IDBValue.h"
 #include "modules/indexeddb/IDBValueWrapping.h"
 #include "modules/indexeddb/WebIDBCallbacksImpl.h"
+#include "platform/Histogram.h"
 #include "platform/SharedBuffer.h"
 #include "platform/heap/Handle.h"
 #include "platform/wtf/PtrUtil.h"
 #include "public/platform/WebBlobInfo.h"
 
 using blink::WebIDBCursor;
 
 namespace blink {
 
+IDBRequest::AsyncTraceState::AsyncTraceState(const char* tracing_name, void* id)
+    : tracing_name_(tracing_name), id_(id) {
+  if (tracing_name_)
+    TRACE_EVENT_ASYNC_BEGIN0("IndexedDB", tracing_name_, id);
+}
+
+void IDBRequest::AsyncTraceState::RecordAndReset() {
+  if (tracing_name_)
+    TRACE_EVENT_ASYNC_END0("IndexedDB", tracing_name_, id_);
+  tracing_name_ = nullptr;
+}
+
+IDBRequest::AsyncTraceState::~AsyncTraceState() {
+  if (tracing_name_)
+    TRACE_EVENT_ASYNC_END0("IndexedDB", tracing_name_, id_);
+}
+
 IDBRequest* IDBRequest::Create(ScriptState* script_state,
                                IDBAny* source,
-                               IDBTransaction* transaction) {
-  IDBRequest* request = new IDBRequest(script_state, source, transaction);
+                               IDBTransaction* transaction,
+                               IDBRequest::AsyncTraceState metrics) {
+  IDBRequest* request =
+      new IDBRequest(script_state, source, transaction, std::move(metrics));
   request->SuspendIfNeeded();
   // Requests associated with IDBFactory (open/deleteDatabase/getDatabaseNames)
   // do not have an associated transaction.
   if (transaction)
     transaction->RegisterRequest(request);
   return request;
 }
 
 IDBRequest::IDBRequest(ScriptState* script_state,
                        IDBAny* source,
-                       IDBTransaction* transaction)
+                       IDBTransaction* transaction,
+                       AsyncTraceState 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());
+  DCHECK((ready_state_ == DONE && !metrics_.is_valid()) ||
+         ready_state_ == kEarlyDeath || !GetExecutionContext());
 }
 
 DEFINE_TRACE(IDBRequest) {
   visitor->Trace(transaction_);
   visitor->Trace(source_);
   visitor->Trace(result_);
   visitor->Trace(error_);
   visitor->Trace(enqueued_events_);
   visitor->Trace(pending_cursor_);
   visitor->Trace(cursor_key_);
@@ skipping 246 matching lines @@
     return EnqueueResponse(key, primary_key, std::move(value));
 
   transaction_->EnqueueResult(WTF::MakeUnique<IDBRequestQueueItem>(
       this, key, primary_key, std::move(value), is_wrapped,
       WTF::Bind(&IDBTransaction::OnResultReady,
                 WrapPersistent(transaction_.Get()))));
 }
 
 void IDBRequest::EnqueueResponse(DOMException* error) {
   IDB_TRACE("IDBRequest::EnqueueResponse(DOMException)");
-  if (!ShouldEnqueueEvent())
+  if (!ShouldEnqueueEvent()) {
+    metrics_.RecordAndReset();
     return;
+  }
 
   error_ = error;
   SetResult(IDBAny::CreateUndefined());
   pending_cursor_.Clear();
   EnqueueEvent(Event::CreateCancelableBubble(EventTypeNames::error));
+  metrics_.RecordAndReset();
 }
 
 void IDBRequest::EnqueueResponse(const Vector<String>& string_list) {
   IDB_TRACE("IDBRequest::onSuccess(StringList)");
-  if (!ShouldEnqueueEvent())
+  if (!ShouldEnqueueEvent()) {
+    metrics_.RecordAndReset();
     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));
+  metrics_.RecordAndReset();
 }
 
 void IDBRequest::EnqueueResponse(std::unique_ptr<WebIDBCursor> backend,
                                  IDBKey* key,
                                  IDBKey* primary_key,
                                  RefPtr<IDBValue>&& value) {
   IDB_TRACE("IDBRequest::EnqueueResponse(IDBCursor)");
-  if (!ShouldEnqueueEvent())
+  if (!ShouldEnqueueEvent()) {
+    metrics_.RecordAndReset();
     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));
+  metrics_.RecordAndReset();
 }
 
 void IDBRequest::EnqueueResponse(IDBKey* idb_key) {
   IDB_TRACE("IDBRequest::EnqueueResponse(IDBKey)");
-  if (!ShouldEnqueueEvent())
+  if (!ShouldEnqueueEvent()) {
+    metrics_.RecordAndReset();
     return;
+  }
 
   if (idb_key && idb_key->IsValid())
     EnqueueResultInternal(IDBAny::Create(idb_key));
   else
     EnqueueResultInternal(IDBAny::CreateUndefined());
+  metrics_.RecordAndReset();
 }
 
 void IDBRequest::EnqueueResponse(const Vector<RefPtr<IDBValue>>& values) {
   IDB_TRACE("IDBRequest::EnqueueResponse([IDBValue])");
-  if (!ShouldEnqueueEvent())
+  if (!ShouldEnqueueEvent()) {
+    metrics_.RecordAndReset();
     return;
+  }
 
   AckReceivedBlobs(values);
   EnqueueResultInternal(IDBAny::Create(values));
+  metrics_.RecordAndReset();
 }
 
 #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();
   return nullptr;
 }
 #endif  // DCHECK_IS_ON()
 
 void IDBRequest::EnqueueResponse(RefPtr<IDBValue>&& value) {
   IDB_TRACE("IDBRequest::EnqueueResponse(IDBValue)");
-  if (!ShouldEnqueueEvent())
+  if (!ShouldEnqueueEvent()) {
+    metrics_.RecordAndReset();
     return;
+  }
 
   AckReceivedBlobs(value.Get());
 
   if (pending_cursor_) {
     // Value should be null, signifying the end of the cursor's range.
     DCHECK(value->IsNull());
     DCHECK(!value->BlobInfo()->size());
     pending_cursor_->Close();
     pending_cursor_.Clear();
   }
 
 #if DCHECK_IS_ON()
   DCHECK(!value->PrimaryKey() ||
          value->KeyPath() == EffectiveObjectStore(source_)->IdbKeyPath());
 #endif
 
   EnqueueResultInternal(IDBAny::Create(std::move(value)));
+  metrics_.RecordAndReset();
 }
 
 void IDBRequest::EnqueueResponse(int64_t value) {
   IDB_TRACE("IDBRequest::EnqueueResponse(int64_t)");
-  if (!ShouldEnqueueEvent())
+  if (!ShouldEnqueueEvent()) {
+    metrics_.RecordAndReset();
     return;
+  }
   EnqueueResultInternal(IDBAny::Create(value));
+  metrics_.RecordAndReset();
 }
 
 void IDBRequest::EnqueueResponse() {
   IDB_TRACE("IDBRequest::EnqueueResponse()");
-  if (!ShouldEnqueueEvent())
+  if (!ShouldEnqueueEvent()) {
+    metrics_.RecordAndReset();
     return;
+  }
   EnqueueResultInternal(IDBAny::CreateUndefined());
+  metrics_.RecordAndReset();
 }
 
 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,
                                  RefPtr<IDBValue>&& value) {
   IDB_TRACE("IDBRequest::EnqueueResponse(IDBKey, IDBKey primaryKey, IDBValue)");
-  if (!ShouldEnqueueEvent())
+  if (!ShouldEnqueueEvent()) {
+    metrics_.RecordAndReset();
     return;
+  }
 
   DCHECK(pending_cursor_);
   SetResultCursor(pending_cursor_.Release(), key, primary_key,
                   std::move(value));
+  metrics_.RecordAndReset();
 }
 
 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 166 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