[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/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 oncontruction and ending on destruction.

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

onconstruction -> missing space?

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

Done.

+  // UMA timing metrics are recorded on RecordUMAMetrics.
+  class ScopedMetricsTracker {
+   public:
+    ScopedMetricsTracker(const char* uma_name, const char* tracing_name, void*);
+    ~ScopedMetricsTracker();
+
+    void RecordUMAMetrics() const;
+
+   private:
+    const char* uma_name_ = nullptr;
+    const char* tracing_name_ = nullptr;
+    void* id_;
+    WTF::TimeTicks start_;
+
+    DISALLOW_COPY_AND_ASSIGN(ScopedMetricsTracker);
+  };
+
+  static IDBRequest* Create(ScriptState*,
+                            IDBAny* source,
+                            IDBTransaction*,
+                            std::unique_ptr<ScopedMetricsTracker>);
   ~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 67 matching lines @@
   // the upcoming "success" or "error").
   void TransactionDidFinishAndDispatch();
 
   IDBCursor* GetResultCursor() const;
 
   void StorePutOperationBlobs(
       HashMap<String, RefPtr<BlobDataHandle>> blob_handles) {
     transit_blob_handles_ = std::move(blob_handles);
   }
 
+  void AssignNewMetrics(std::unique_ptr<ScopedMetricsTracker> metrics) {
+    DCHECK(!metrics_);
+    metrics_ = std::move(metrics);
+  }
+
  protected:
-  IDBRequest(ScriptState*, IDBAny* source, IDBTransaction*);
+  IDBRequest(ScriptState*,
+             IDBAny* source,
+             IDBTransaction*,
+             std::unique_ptr<ScopedMetricsTracker>);
   void EnqueueEvent(Event*);
   void DequeueEvent(Event*);
   virtual bool ShouldEnqueueEvent() const;
   void EnqueueResultInternal(IDBAny*);
   void SetResult(IDBAny*);
 
   // EventTarget
   DispatchEventResult DispatchEventInternal(Event*) override;
 
   Member<IDBTransaction> transaction_;
   ReadyState ready_state_ = PENDING;
   bool request_aborted_ = false;  // May be aborted by transaction then receive
                                   // async onsuccess; ignore vs. assert.
   // Maintain the isolate so that all externally allocated memory can be
   // registered against it.
   v8::Isolate* isolate_;
 
  private:
   void SetResultCursor(IDBCursor*,
                        IDBKey*,
                        IDBKey* primary_key,
                        PassRefPtr<IDBValue>);
   void AckReceivedBlobs(const IDBValue*);
   void AckReceivedBlobs(const Vector<RefPtr<IDBValue>>&);
 
+  void MaybeRecordMetrics() {

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

metrics_ only seems to be null in testing.

1) Can this be RecordMetrics()? It seems to me that the testing situation is an
implementation detail.

2) How difficult would it be to pass non-null data all the time, so we don't
have separate code paths in unit tests vs everywhere else?

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

Done.

+    if (metrics_) {
+      metrics_->RecordUMAMetrics();
+      metrics_.reset();
+    }
+  }
+
   void ClearPutOperationBlobs() { transit_blob_handles_.clear(); }
 
   Member<IDBAny> source_;
   Member<IDBAny> result_;
   Member<DOMException> error_;
 
+  std::unique_ptr<ScopedMetricsTracker> 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 15 matching lines @@
   bool did_throw_in_event_handler_ = false;
 
   // Pointer back to the WebIDBCallbacks that holds a persistent reference to
   // this object.
   WebIDBCallbacks* web_callbacks_ = nullptr;
 };
 
 }  // namespace blink
 
 #endif  // IDBRequest_h