Rewrite LoadExpectation to v1.0.

tracing/tracing/model/user_model/load_expectation.html

Index: tracing/tracing/model/user_model/load_expectation.html
diff --git a/tracing/tracing/model/user_model/load_expectation.html b/tracing/tracing/model/user_model/load_expectation.html
index a4ec0113fabd676cac89f131f7f99c8597644520..7701a0db3027089d77ed8c8378cf38217530b6e6 100644
--- a/tracing/tracing/model/user_model/load_expectation.html
+++ b/tracing/tracing/model/user_model/load_expectation.html
@@ -11,6 +11,128 @@ found in the LICENSE file.
 'use strict';
 
 tr.exportTo('tr.model.um', function() {
+  var LoadEvents = {
+    /**
+     * Returns true if event is relevant to loading.
+     *
+     * @param {!tr.model.Event} event
+     * @return {boolean}
+     */
+    isLoadEvent: function(event) {
+      return LoadEvents.isRenderFrameImplEvent(event) ||
+             LoadEvents.isStartEvent(event) ||
+             LoadEvents.isEndEvent(event) ||
+             LoadEvents.isPaintEvent(event) ||
+             LoadEvents.isLayoutEvent(event);
+    },
+
+    isLayoutEvent: function(event) {
+      return event.title === 'FrameView::performLayout';
+    },
+
+    /**
+     * Returns true if event could signify the start of a load.
+     *
+     * @param {!tr.model.Event} event
+     * @return {boolean}
+     */
+    isStartEvent: function(event) {
+      return LoadEvents.isOnNavigateEvent(event) ||
+             LoadEvents.isNavigationStartEvent(event) ||
+             LoadEvents.isStartProvisionalEvent(event) ||
+             LoadEvents.isStartLoadingEvent(event) ||
+             LoadEvents.isCommitEvent(event);
+    },
+
+    isRenderFrameImplEvent: function(event) {
+      return event.title.indexOf('RenderFrameImpl::') === 0;
+    },
+
+    /**
+     * Returns true if event could be considered to signify the end of a Load.
+     *
+     * @param {!tr.model.Event} event
+     * @return {boolean}
+     */
+    isEndEvent: function(event) {
+      return LoadEvents.isFailEvent(event) ||
+             LoadEvents.isFinishDocumentEvent(event) ||
+             LoadEvents.isFirstContentfulPaintEvent(event) ||
+             LoadEvents.isLoadFinishedEvent(event) ||
+             LoadEvents.isFinishLoadEvent(event);
+    },
+
+    isFinishLoadEvent: function(event) {
+      return event.title === 'RenderFrameImpl::didFinishLoad';
+    },
+
+    isLoadFinishedEvent: function(event) {
+      return ((event.title === 'LoadFinished') &&
+              tr.b.hasCategory(event.category, 'WebCore'));
+    },
+
+    isFinishDocumentEvent: function(event) {
+      return event.title === 'RenderFrameImpl::didFinishDocumentLoad';
+    },
+
+    /**
+     * Returns true if event signifies failure of a load.
+     *
+     * @param {!tr.model.Event} event
+     * @return {boolean}
+     */
+    isFailEvent: function(event) {
+      return ((event.title === 'RenderFrameImpl::didFailLoad') ||
+              (event.title === 'RenderFrameImpl::didFailProvisionalLoad'));
+    },
+
+    isPaintEvent: function(event) {
+      return ((event.title === 'Paint') &&
+              tr.b.hasCategory(event.category, 'devtools.timeline'));
+    },
+
+    isStartLoadingEvent: function(event) {
+      return event.title === 'RenderFrameImpl::didStartLoading';
+    },
+
+    isCommitEvent: function(event) {
+      return event.title === 'RenderFrameImpl::didCommitProvisionalLoad';
+    },
+
+    isStartProvisionalEvent: function(event) {
+      return event.title === 'RenderFrameImpl::didStartProvisionalLoad';
+    },
+
+    // This render-process instant event marks the first contentful paint in a
+    // main frame.
+    isFirstContentfulPaintEvent: function(event) {
+      return event.title === 'firstContentfulPaint';
+    },
+
+    isNavigationStartEvent: function(event) {
+      return event.title === 'NavigationTiming navigationStart';
+    },
+
+    isOnNavigateEvent: function(event) {
+      return event.title === 'RenderFrameImpl::OnNavigate';
+    },
+
+    findRenderFrameSnapshotForEvent: function(event) {
+      var renderFrameSnapshot = undefined;
+      event.contexts.forEach(function(context) {
+        if (context.type === 'FrameBlameContext')
+          renderFrameSnapshot = context.snapshot;
+        else if (context.type === 'FrameTreeNodeBlameContext')
+          renderFrameSnapshot = context.snapshot.renderFrameSnapshot;
+      });
+
+      if (renderFrameSnapshot === undefined)
+        throw new Error('Unable to find frame for ' + event.title);
+
+      return renderFrameSnapshot;
+    }
+  };
+
   var LOAD_SUBTYPE_NAMES = {
     SUCCESSFUL: 'Successful',
     FAILED: 'Failed',
@@ -28,32 +150,81 @@ tr.exportTo('tr.model.um', function() {
     tr.model.um.UserExpectation.call(
         this, parentModel, initiatorTitle, start, duration);
 
-    // |renderProcess| is the renderer process that contains the loading
-    // RenderFrame.
-    this.renderProcess = undefined;
+    this.navigationEvent_ = undefined;
+    this.frameTreeNodeSnapshot_ = undefined;
+    this.layoutEvents_ = undefined;
+    this.paintEvents_ = undefined;
+    this.firstMeaningfulPaintEvent_ = undefined;
+  }
 
-    // |renderMainThread| is the CrRendererMain thread in the |renderProcess|
-    // that contains the loading RenderFrame.
-    this.renderMainThread = undefined;
+  LoadExpectation.prototype = {
+    __proto__: tr.model.um.UserExpectation.prototype,
+    constructor: LoadExpectation,
 
-    // |routingId| identifies the loading RenderFrame within the renderer
-    // process.
-    this.routingId = undefined;
+    get frameTreeNodeSnapshot() {
+      if (this.frameTreeNodeSnapshot_ === undefined) {
+        this.associatedEvents.forEach(function(event) {
+          var renderFrameSnapshot = LoadEvents.findRenderFrameSnapshotForEvent(
+              event);
+          if (renderFrameSnapshot) {
+            this.frameTreeNodeSnapshot_ =
+              renderFrameSnapshot.frameTreeNodeSnapshot;
+          }
+        }, this);
+      }
+      return this.frameTreeNodeSnapshot_;
+    },
 
-    // |parentRoutingId| identifies the RenderFrame that created and contains
-    // the loading RenderFrame.
-    this.parentRoutingId = undefined;
+    get navigationEvent() {
+      if (this.navigationEvent_ === undefined) {
+        this.associatedEvents.forEach(function(event) {
+          if ((this.navigationEvent_ === undefined) &&
+              (LoadEvents.isNavigationStartEvent(event) ||
+               LoadEvents.isOnNavigateEvent(event)))
+            this.navigationEvent_ = event;
+        }, this);
+      }
+      return this.navigationEvent_;
+    },
 
-    // |loadFinishedEvent|, if present, signals that this is a main frame.
-    this.loadFinishedEvent = undefined;
+    get layoutEvents() {
+      if (this.layoutEvents_ === undefined) {
+        this.layoutEvents_ = new tr.model.EventSet();
+        this.associatedEvents.forEach(function(event) {
+          if (event.title === PERFORM_LAYOUT_TITLE)
+            this.layoutEvents_.push(event);
+        }, this);
+      }
+      return this.layoutEvents_;
+    },
 
-    // Startup LoadIRs do not have renderProcess, routingId, or
-    // parentRoutingId. Maybe RenderLoadIR should be a separate class?
-  }
+    get paintEvents() {
+      if (this.paintEvents_ === undefined) {
+        this.paintEvents_ = new tr.model.EventSet();
+        this.associatedEvents.forEach(function(event) {
+          if (event.title === DEVTOOLS_PAINT_TITLE)
+            this.paintEvents_.push(event);
+        }, this);
+      }
+      return this.paintEvents_;
+    },
 
-  LoadExpectation.prototype = {
-    __proto__: tr.model.um.UserExpectation.prototype,
-    constructor: LoadExpectation
+    get firstContentfulPaintEvent() {
+      if (this.firstContentfulPaintEvent_ === undefined) {
+        this.associatedEvents.forEach(function(event) {
+          if (event.title === FIRST_CONTENTFUL_PAINT_TITLE)
+            this.firstContentfulPaintEvent_ = event;
+        }, this);
+      }
+      return this.firstContentfulPaintEvent_;
+    },
+
+    get firstMeaningfulPaintEvent() {
+      if (this.firstMeaningfulPaintEvent_ === undefined) {
+        // TODO(ksakamoto): Find FMP.
+      }
+      return this.firstMeaningfulPaintEvent_;
+    }
   };
 
   tr.model.um.UserExpectation.register(LoadExpectation, {
@@ -63,6 +234,7 @@ tr.exportTo('tr.model.um', function() {
 
   return {
     LOAD_SUBTYPE_NAMES: LOAD_SUBTYPE_NAMES,
+    LoadEvents: LoadEvents,
     LoadExpectation: LoadExpectation
   };
 });