Move bot-list and task-list to use pageable-data

appengine/swarming/elements/res/imp/tasklist/task-list-data.html

 <!--
   Copyright 2016 The LUCI Authors. All rights reserved.
   Use of this source code is governed under the Apache License, Version 2.0
   that can be found in the LICENSE file.
 
   This in an HTML Import-able file that contains the definition
   of the following elements:
 
     <bot-list-data>
 
@@ skipping 45 matching lines @@
       ],
 
       properties: {
         // inputs
         auth_headers: {
           type: Object,
           observer: "signIn",
         },
         query_params: {
           type: Object,
-          observer: "_request",
+        },
+        tasks: {
+          type: Array,
         },
 
         // outputs
         busy: {
           type: Boolean,
-          computed: "_or(_busy1,_busy2,_busy3)",
+          computed: "_or(_busy2,_busy1)",
           notify: true,
         },
         primary_map: {
           type: Object,
-          computed: "_primaryMap(_tags,_dimensions,tasks)",
+          computed: "_primaryMap(_tags,_dimensions,tasks.*)",
           notify: true,
         },
         primary_arr: {
           type: Array,
           computed: "_primaryArr(primary_map)",
           notify: true,
         },
-        tasks: {
-          type: Array,
-          computed: "_tasks(_list)",
-          notify: true,
-        },
+
 
         // private
-         _busy1: {
-          type: Boolean,
-          value: false
-        },
         _busy2: {
           type: Boolean,
           value: false
         },
-        _busy3: {
+        _busy1: {
           type: Boolean,
           value: false
         },
         _dimensions: {
           type: Object,
         },
         _list: {
           type: Object,
         },
         _tags: {
           type: Object,
         },
       },
 
       signIn: function(){
         this._getJsonAsync("_tags", "/_ah/api/swarming/v1/tasks/tags",
           "_busy2", this.auth_headers);
         this._getJsonAsync("_dimensions","/_ah/api/swarming/v1/bots/dimensions",
-          "_busy3", this.auth_headers);
-
-        this._request();
+          "_busy1", this.auth_headers);
       },
 
       _primaryArr: function(map) {
         var arr = Object.keys(map);
         arr.sort();
         return arr;
       },
 
-      _primaryMap: function(tags, dims, tasks) {
+      _primaryMap: function(tags, dims) {
         tags = (tags && tags.tasks_tags) || [];
         dims = (dims && dims.bots_dimensions) || [];
-        tasks = tasks || [];
+        tasks = this.tasks || [];
         var map = {};
         // We combine all the tags reported by the tags endpoint, all known
         // dimensions from the dimensions endpoint, and the tags seen in the
         // returned tasks, just in case they didn't show up in the first two.
         // This way a user can filter by what the data actually has and can
         // discover new tags to filter by.
         tags.forEach(function(t) {
           if (!map[t.key]) {
             map[t.key] = {};
           }
@@ skipping 57 matching lines @@
 
         // TODO(kjlubick): Allow a person to sort on the task list by bot
         pMap["bot"] = [];
         TIMES.forEach(function(t) {
           pMap[t] = [];
         });
 
         return pMap;
       },
 
-      _request: function() {
-        // wait until the user has logged in and the filters have loaded before requesting this to avoid double or even triple requests.
-        if (!this.auth_headers || !this.query_params) {
-          return;
-        }
-        this._getJsonAsync("_list", "/_ah/api/swarming/v1/tasks/list",
-          "_busy1", this.auth_headers, this.query_params);
-      },
-
-      _tasks: function() {
-        if (!this._list || !this._list.items) {
+      parseTasks: function(json) {
+        console.log("ping", json);
+        if (!json|| !json.items) {
           return [];
         }
         var now = new Date();
 
         // Do any preprocessing here
-        this._list.items.forEach(function(t) {
+        json.items.forEach(function(t) {
           var tagMap = {};
           t.tags = t.tags || [];
           t.tags.forEach(function(tag) {
             var split = tag.split(":", 1)
             var key = split[0];
             var rest = tag.substring(key.length + 1);
             tagMap[key] = rest;
           });
           t.tagMap = tagMap;
 
           TIMES.forEach(function(time) {
             if (t[time]) {
               t[time] = new Date(t[time]);
               t["human_"+time] = sk.human.localeTime(t[time]);
             }
           });
           // Running tasks have no duration set, so we can figure it out.
           if (!t.duration && t.state === this.RUNNING && t.started_ts){
             t.duration = (now - t.started_ts) / 1000;
           }
           // Make the duration human readable
           if (t.duration){
             t.human_duration = this._humanDuration(t.duration);
           }
         }.bind(this));
-        return this._list.items;
+        return json.items;
       }
     });
   })();
   </script>
 </dom-module>