| <!DOCTYPE html> |
| <!-- |
| Copyright 2015 The Chromium Authors. All rights reserved. |
| Use of this source code is governed by a BSD-style license that can be |
| found in the LICENSE file. |
| --> |
| |
| <link rel="import" href="/base/task.html"> |
| <link rel="import" href="/core/filter.html"> |
| <link rel="import" href="/core/selection.html"> |
| <link rel="import" href="/core/scripting_object.html"> |
| <link rel="import" href="/extras/tquery/context.html"> |
| <link rel="import" href="/extras/tquery/filter_all_of.html"> |
| <link rel="import" href="/extras/tquery/filter_any_of.html"> |
| <link rel="import" href="/extras/tquery/filter_has_ancestor.html"> |
| <link rel="import" href="/extras/tquery/filter_has_duration.html"> |
| <link rel="import" href="/extras/tquery/filter_has_title.html"> |
| <link rel="import" href="/extras/tquery/filter_is_top_level.html"> |
| |
| <script> |
| 'use strict'; |
| |
| tr.exportTo('tr.e.tquery', function() { |
| function TQuery(selectionController) { |
| tr.c.ScriptingObject.call(this); |
| |
| this.selectionController_ = selectionController; |
| this.parent_ = undefined; |
| this.filterExpression_ = undefined; |
| // Memoized filtering result. |
| this.selection_ = undefined; |
| }; |
| |
| TQuery.prototype = { |
| __proto__: tr.c.ScriptingObject.prototype, |
| |
| onModelChanged: function() { |
| this.selection_ = undefined; |
| }, |
| |
| get selectionController() { |
| return this.selectionController_; |
| }, |
| |
| // Append a new filter expression to this query and return a query node |
| // that represents the result. |
| filter: function(filterExpression) { |
| var result = new TQuery(this.selectionController_); |
| result.parent_ = this; |
| result.filterExpression_ = |
| tr.e.tquery.Filter.normalizeFilterExpression(filterExpression); |
| return result; |
| }, |
| |
| // Creates a graph of {Task} objects which will compute the selections for |
| // this filter object and all of its parents. The return value is an object |
| // with the following fields: |
| // - rootTask: {Task} which should be executed to kick off processing for |
| // the entire task graph. |
| // - lastTask: The final {Task} of the graph. Can be used by the caller to |
| // enqueue additional processing at the end. |
| // - lastNode: The last filter object in the task. It's selection property |
| // will contain the filtering result once |finalTask| |
| // completes. |
| createFilterTaskGraph_: function() { |
| // List of nodes in order from the current one to the root. |
| var nodes = []; |
| var node = this; |
| while (node !== undefined) { |
| nodes.push(node); |
| node = node.parent_; |
| } |
| |
| var rootTask = new tr.b.Task(); |
| var lastTask = rootTask; |
| for (var i = nodes.length - 1; i >= 0; i--) { |
| var node = nodes[i]; |
| // Reuse any memoized result. |
| if (node.selection_ !== undefined) |
| continue; |
| node.selection_ = new tr.c.Selection(); |
| if (node.parent_ === undefined) { |
| // If this is the root, start by collecting all objects from the |
| // selection controller. |
| lastTask = lastTask.after( |
| this.selectEverythingAsTask_(node.selection_)); |
| } else { |
| // Otherwise execute the filter expression for this node and fill |
| // in its selection. |
| var prevNode = nodes[i + 1]; |
| lastTask = this.createFilterTaskForNode_(lastTask, node, prevNode); |
| } |
| } |
| return {rootTask: rootTask, lastTask: lastTask, lastNode: node}; |
| }, |
| |
| createFilterTaskForNode_: function(lastTask, node, prevNode) { |
| return lastTask.after(function() { |
| // TODO(skyostil): Break into subtasks. |
| node.evaluateFilterExpression_( |
| prevNode.selection_, node.selection_); |
| }, this); |
| }, |
| |
| // Applies the result of a filter expression for a given event and all |
| // of its subslices and adds the matching events to an output selection. |
| evaluateFilterExpression_: function(inputSelection, outputSelection) { |
| var seenEvents = {}; |
| inputSelection.forEach(function(event) { |
| var context = new tr.e.tquery.Context(); |
| context.event = event; |
| this.evaluateFilterExpressionForEvent_( |
| context, inputSelection, outputSelection, seenEvents); |
| }.bind(this)); |
| }, |
| |
| evaluateFilterExpressionForEvent_: function( |
| context, inputSelection, outputSelection, seenEvents) { |
| var event = context.event; |
| if (inputSelection.contains(event) && !seenEvents[event.guid]) { |
| seenEvents[event.guid] = true; |
| if (!this.filterExpression_ || |
| this.filterExpression_.evaluate(context)) |
| outputSelection.push(event); |
| } |
| if (!event.subSlices) |
| return; |
| context = context.push(event); |
| for (var i = 0; i < event.subSlices.length; i++) { |
| context.event = event.subSlices[i]; |
| this.evaluateFilterExpressionForEvent_( |
| context, inputSelection, outputSelection, seenEvents); |
| } |
| }, |
| |
| // Show the result as a highlight on the selection controller. Returns a |
| // {Task} which runs the query and sets the highlight. |
| show: function() { |
| var graph = this.createFilterTaskGraph_(); |
| |
| graph.lastTask = graph.lastTask.after(function() { |
| this.selectionController.showScriptControlSelection( |
| graph.lastNode.selection_); |
| }, this); |
| return graph.rootTask; |
| }, |
| |
| // Returns a task that fills the given selection with everything reachable |
| // by the selection controller. |
| selectEverythingAsTask_: function(selection) { |
| var passThroughFilter = new tr.c.Filter(); |
| var filterTask = |
| this.selectionController.addAllEventsMatchingFilterToSelectionAsTask( |
| passThroughFilter, selection); |
| return filterTask; |
| }, |
| |
| get selection() { |
| if (this.selection_ === undefined) { |
| var graph = this.createFilterTaskGraph_(); |
| tr.b.Task.RunSynchronously(graph.rootTask); |
| } |
| return this.selection_; |
| } |
| }; |
| tr.c.ScriptingObjectRegistry.register( |
| new TQuery(), |
| { |
| name: '$t' |
| } |
| ); |
| |
| return { |
| TQuery: TQuery |
| }; |
| }); |
| </script> |
