[IndexedDB] Adding async tracing for renderer calls.

third_party/WebKit/Source/modules/indexeddb/IDBRequest.h

 /*
  * 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 13 matching lines @@
  * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #ifndef IDBRequest_h
 #define IDBRequest_h
 
 #include <memory>
 
+#include "base/macros.h"
 #include "bindings/core/v8/ScriptValue.h"
 #include "core/dom/DOMStringList.h"
 #include "core/dom/SuspendableObject.h"
 #include "core/events/EventListener.h"
 #include "core/events/EventTarget.h"
 #include "modules/EventModules.h"
 #include "modules/ModulesExport.h"
 #include "modules/indexeddb/IDBAny.h"
 #include "modules/indexeddb/IDBTransaction.h"
 #include "modules/indexeddb/IndexedDB.h"
 #include "platform/bindings/ActiveScriptWrappable.h"
 #include "platform/bindings/ScriptState.h"
 #include "platform/blob/BlobData.h"
 #include "platform/heap/Handle.h"
 #include "platform/wtf/HashMap.h"
 #include "platform/wtf/RefPtr.h"
+#include "platform/wtf/Time.h"
 #include "public/platform/WebBlobInfo.h"
 #include "public/platform/modules/indexeddb/WebIDBCursor.h"
 #include "public/platform/modules/indexeddb/WebIDBTypes.h"
 
 namespace blink {
 
 class DOMException;
 class ExceptionState;
 class IDBCursor;
 struct IDBDatabaseMetadata;
 class IDBValue;
 
 class MODULES_EXPORT IDBRequest : public EventTargetWithInlineData,
                                   public ActiveScriptWrappable<IDBRequest>,
                                   public SuspendableObject {
   DEFINE_WRAPPERTYPEINFO();
   USING_GARBAGE_COLLECTED_MIXIN(IDBRequest);
 
  public:
-  static IDBRequest* Create(ScriptState*, IDBAny* source, IDBTransaction*);
+  // Records async tracing, starting on contruction and ending on destruction or
+  // a call to |RecordAndReset()|.
+  class AsyncTraceState {
+   public:
+    AsyncTraceState() {}
+    AsyncTraceState(const char* tracing_name, void*);
+    ~AsyncTraceState();
+    AsyncTraceState(AsyncTraceState&& other) {
+      this->tracing_name_ = other.tracing_name_;
+      this->id_ = other.id_;
+      other.tracing_name_ = nullptr;
+    }
+    AsyncTraceState& operator=(AsyncTraceState&& rhs) {
+      this->tracing_name_ = rhs.tracing_name_;
+      this->id_ = rhs.id_;
+      rhs.tracing_name_ = nullptr;
+      return *this;
+    }
+
+    bool is_valid() const { return tracing_name_; }
+    void RecordAndReset();
+
+   private:
+    const char* tracing_name_ = nullptr;
+    void* id_;
+
+    DISALLOW_COPY_AND_ASSIGN(AsyncTraceState);
+  };
+
+  static IDBRequest* Create(ScriptState*,
+                            IDBAny* source,
+                            IDBTransaction*,
+                            AsyncTraceState);
   ~IDBRequest() override;
   DECLARE_VIRTUAL_TRACE();
 
   v8::Isolate* GetIsolate() const { return isolate_; }
   ScriptValue result(ScriptState*, ExceptionState&);
   DOMException* error(ExceptionState&) const;
   ScriptValue source(ScriptState*) const;
   IDBTransaction* transaction() const { return transaction_.Get(); }
 
   bool isResultDirty() const { return result_dirty_; }
@@ skipping 131 matching lines @@
 #if DCHECK_IS_ON()
   inline bool TransactionHasQueuedResults() const {
     return transaction_ && transaction_->HasQueuedResults();
   }
 #endif  // DCHECK_IS_ON()
 
 #if DCHECK_IS_ON()
   inline IDBRequestQueueItem* QueueItem() const { return queue_item_; }
 #endif  // DCHECK_IS_ON()
 
+  void AssignNewMetrics(AsyncTraceState metrics) {
+    DCHECK(!metrics_.is_valid());
+    metrics_ = std::move(metrics);
+  }
+
  protected:
-  IDBRequest(ScriptState*, IDBAny* source, IDBTransaction*);
+  IDBRequest(ScriptState*, IDBAny* source, IDBTransaction*, AsyncTraceState);
   void EnqueueEvent(Event*);
   void DequeueEvent(Event*);
   virtual bool ShouldEnqueueEvent() const;
   void EnqueueResultInternal(IDBAny*);
   void SetResult(IDBAny*);
 
   // Overridden by IDBOpenDBRequest.
   virtual void EnqueueResponse(int64_t);
 
   // EventTarget
@@ skipping 25 matching lines @@
   void EnqueueResponse(IDBKey*);
   void EnqueueResponse(std::unique_ptr<WebIDBCursor>,
                        IDBKey*,
                        IDBKey* primary_key,
                        RefPtr<IDBValue>&&);
   void EnqueueResponse(IDBKey*, IDBKey* primary_key, RefPtr<IDBValue>&&);
   void EnqueueResponse(RefPtr<IDBValue>&&);
   void EnqueueResponse(const Vector<RefPtr<IDBValue>>&);
   void EnqueueResponse();
 
+  void ClearPutOperationBlobs() { transit_blob_handles_.clear(); }
+
   Member<IDBAny> source_;
   Member<IDBAny> result_;
   Member<DOMException> error_;
 
+  AsyncTraceState metrics_;
+
   bool has_pending_activity_ = true;
   HeapVector<Member<Event>> enqueued_events_;
 
   // Only used if the result type will be a cursor.
   IndexedDB::CursorType cursor_type_ = IndexedDB::kCursorKeyAndValue;
   WebIDBCursorDirection cursor_direction_ = kWebIDBCursorDirectionNext;
   // When a cursor is continued/advanced, |result_| is cleared and
   // |pendingCursor_| holds it.
   Member<IDBCursor> pending_cursor_;
   // New state is not applied to the cursor object until the event is
@@ skipping 21 matching lines @@
   // Non-null while this request is queued behind other requests that are still
   // getting post-processed.
   //
   // The IDBRequestQueueItem is owned by the result queue in IDBTransaction.
   IDBRequestQueueItem* queue_item_ = nullptr;
 };
 
 }  // namespace blink
 
 #endif  // IDBRequest_h