Removed delta-updates, task queueing and batching.

The delta-events were redundant because a full list of all
tasks are re-sent every second and delta-events were batched
on 900 millisecond intervals anyway to cut down on screen
redraws.
Also fixes small issue causing exceptions when opening context-menus.  


BUG=114880,114615,115134
TEST=manually


Review URL: http://codereview.chromium.org/9432006

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@123631 0039d316-1c4b-4281-b951-d872f2087c98

5 files changed, 38 insertions, 222 deletions

diff --git a/chrome/browser/resources/task_manager/main.js b/chrome/browser/resources/task_manager/main.js
index 85b6489..9bc0d28 100644
--- a/chrome/browser/resources/task_manager/main.js
+++ b/chrome/browser/resources/task_manager/main.js
@@ -21,8 +21,8 @@ TaskManager.prototype = {
   },
 
   /**
-   * Handle selection change.
-   * This is also called when data of tasks are refleshed, even if selection
+   * Handles selection changes.
+   * This is also called when data of tasks are refreshed, even if selection
    * has not been changed.
    */
   onSelectionChange: function () {
@@ -153,9 +153,6 @@ TaskManager.prototype = {
     // Populate the static localized strings.
     i18nTemplate.process(this.document_, templateData);
 
-    if (taskmanagerForceUpdate)
-      this.processTaskChange(pendingTaskUpdates);
-
     measureTime.recordInterval('Load.DOM');
     measureTime.recordInterval('Load.Total');
 
@@ -529,57 +526,34 @@ TaskManager.prototype = {
   },
 
   /**
-   * Updates the task list with the |pendingTaskUpdates| queue.
-   * This function does nothing if it is less than 900 ms after last update. In
-   * such case, the queue remains at that time, and it will update the list
-   * at next change event or at periodical every-second reflesh.
+   * Updates the task list with the supplied task.
    * @private
    */
-  processTaskChange: function(pendingTaskUpdates) {
-    var now = +new Date();  // Casts to integer and gets milliseconds.
-
-    // If it is less than 900 ms after last update, the list isn't updated now.
-    // 900 ms is a time to allow at least periodical reflesh of every second.
-    if (!taskmanagerForceUpdate && (now - this.lastUpdate_) < 900)
-      return;
-    this.lastUpdate_ = now;
-    taskmanagerForceUpdate = false;
-
+  processTaskChange: function(task) {
     var dm = this.dataModel_;
     var sm = this.selectionModel_;
-    if (!dm || !sm || pendingTaskUpdates.length == 0)
-      return;
+    if (!dm || !sm) return;
 
     this.table_.list.startBatchUpdates();
     sm.beginChange();
 
-    var task;
-    while (task = pendingTaskUpdates.shift()) {
-      var type = task.type;
-      var start = task.start;
-      var length = task.length;
-      var tasks = task.tasks;
-      if (type == 'change') {
-        // We have to store the selected indexes and restore them after
-        // splice(), because it might replace some items but the replaced
-        // items would lost the selection.
-        var oldSelectedIndexes = sm.selectedIndexes;
-
-        var args = [].slice.call(tasks);
-        args.unshift(start, length);
-        dm.splice.apply(dm, args);
-
-        sm.selectedIndexes = oldSelectedIndexes.filter(function(index) {
-          return index < dm.length;
-        });
-      } else if (type == 'add') {
-        var args = [].slice.call(tasks);
-        args.unshift(start, 0);
-        dm.splice.apply(dm, args);
-      } else if (type == 'remove') {
-        dm.splice(start, length);
-      }
-    }
+    var type = task.type;
+    var start = task.start;
+    var length = task.length;
+    var tasks = task.tasks;
+
+    // We have to store the selected indexes and restore them after
+    // splice(), because it might replace some items but the replaced
+    // items would lose the selection.
+    var oldSelectedIndexes = sm.selectedIndexes;
+
+    var args = tasks.slice();
+    args.unshift(start, dm.length);
+    dm.splice.apply(dm, args);
+
+    sm.selectedIndexes = oldSelectedIndexes.filter(function(index) {
+      return index < dm.length;
+    });
 
     var pids = [];
     for (var i = 0; i < dm.length; i++) {
@@ -629,7 +603,7 @@ TaskManager.prototype = {
 
   /**
    * Store resourceIndex of target resource of context menu, because resource
-   * will be replaced when it is refleshed.
+   * will be replaced when it is refreshed.
    */
   onTableContextMenuOpened_: function (e) {
     if (!this.isFinishedInitDelayed_)
@@ -646,16 +620,13 @@ TaskManager.prototype = {
     activate_menuitem.disabled = true;
 
     var target = e.target;
-    var classes = target.classList;
-    while (target &&
-        Array.prototype.indexOf.call(classes, 'detail-title') == -1) {
-      target = target.parentNode;
-      classes = target.classList;
+    for (; ; target = target.parentNode) {
+      if (!target) return;
+      var classes = target.classList;
+      if (classes &&
+          Array.prototype.indexOf.call(classes, 'detail-title') != -1) break;
     }
 
-    if (!target)
-      return;
-
     var index_in_group = target.index_in_group;
 
     // Sets the uniqueId for current target page under the mouse corsor.
diff --git a/chrome/browser/resources/task_manager/preload.js b/chrome/browser/resources/task_manager/preload.js
index 9afd4b8..d5e9952 100644
--- a/chrome/browser/resources/task_manager/preload.js
+++ b/chrome/browser/resources/task_manager/preload.js
@@ -5,53 +5,14 @@
 // Defines global variables.
 var commands = TaskManagerCommands;
 var taskmanager = undefined;  // This will be instantiated in main.js.
-var taskmanagerForceUpdate = false;
-var pendingTaskUpdates = [];
-
-/**
- * Invoked when new items are added.
- */
-function taskAdded(start, length, tasks) {
-  pendingTaskUpdates.push(
-      {type: 'add', start: start, length: length, tasks: tasks});
-
-  // Sometimes this can get called too early.
-  if (!taskmanager)
-    return;
-  taskmanager.processTaskChange(pendingTaskUpdates);
-}
 
 /**
  * Invoked when a range of items has changed.
  */
 function taskChanged(start, length, tasks) {
-  pendingTaskUpdates.push(
-      {type: 'change', start: start, length: length, tasks: tasks});
+  var task = {type: 'change', start: start, length: length, tasks: tasks};
 
-  if (taskmanager)
-    taskmanager.processTaskChange(pendingTaskUpdates);
-}
-
-/**
- * Invoked when a range of items has been removed.
- */
-function taskRemoved(start, length) {
-  pendingTaskUpdates.push(
-      {type: 'remove', start: start, length: length, tasks: undefined});
-
-  if (taskmanager)
-    taskmanager.processTaskChange(pendingTaskUpdates);
-}
-
-/**
- * Invoked when the initialization of the model has been finished and periodical
- * updates is started.
- */
-function onReadyPeriodicalUpdate() {
-  taskmanagerForceUpdate = true;
-
-  if (taskmanager)
-    taskmanager.processTaskChange(pendingTaskUpdates);
+  if (taskmanager) taskmanager.processTaskChange(task);
 }
 
 // Enable the taskmanager model before the loading of scripts.
@@ -60,7 +21,7 @@ function onReadyPeriodicalUpdate() {
     if (DEFAULT_COLUMNS[i][3])
       commands.setUpdateColumn(DEFAULT_COLUMNS[i][0], true);
   }
+  commands.enableTaskManager();
   commands.setUpdateColumn('canInspect', true);
   commands.setUpdateColumn('canActivate', true);
-  commands.enableTaskManager();
 })();
diff --git a/chrome/browser/task_manager/task_manager.cc b/chrome/browser/task_manager/task_manager.cc
index 976b869..056bc7d 100644
--- a/chrome/browser/task_manager/task_manager.cc
+++ b/chrome/browser/task_manager/task_manager.cc
@@ -629,10 +629,9 @@ void TaskManagerModel::StartUpdating() {
   // If update_state_ is STOPPING, it means a task is still pending.  Setting
   // it to TASK_PENDING ensures the tasks keep being posted (by Refresh()).
   if (update_state_ == IDLE) {
-      MessageLoop::current()->PostDelayedTask(
+      MessageLoop::current()->PostTask(
           FROM_HERE,
-          base::Bind(&TaskManagerModel::Refresh, this),
-          base::TimeDelta::FromMilliseconds(kUpdateTimeMs));
+          base::Bind(&TaskManagerModel::Refresh, this));
   }
   update_state_ = TASK_PENDING;
 
diff --git a/chrome/browser/ui/webui/task_manager_handler.cc b/chrome/browser/ui/webui/task_manager_handler.cc
index 71d76ad..23eeda1 100644
--- a/chrome/browser/ui/webui/task_manager_handler.cc
+++ b/chrome/browser/ui/webui/task_manager_handler.cc
@@ -226,96 +226,17 @@ TaskManagerHandler::~TaskManagerHandler() {
 // TaskManagerHandler, public: -----------------------------------------------
 
 void TaskManagerHandler::OnModelChanged() {
-  const int count = model_->GroupCount();
-
-  base::FundamentalValue start_value(0);
-  base::FundamentalValue length_value(count);
-  base::ListValue tasks_value;
-  for (int i = 0; i < count; ++i)
-    tasks_value.Append(CreateTaskGroupValue(model_, i, enabled_columns_));
-
-  if (is_enabled_) {
-    web_ui()->CallJavascriptFunction("taskChanged",
-                                     start_value, length_value, tasks_value);
-  }
+  OnGroupChanged(0, model_->GroupCount());
 }
 
 void TaskManagerHandler::OnItemsChanged(const int start, const int length) {
-  UpdateResourceGroupTable(start, length);
-
-  // Converts from an index of resources to an index of groups.
-  int group_start = model_->GetGroupIndexForResource(start);
-  int group_end = model_->GetGroupIndexForResource(start + length - 1);
-
-  OnGroupChanged(group_start, group_end - group_start + 1);
+  OnGroupChanged(0, model_->GroupCount());
 }
 
 void TaskManagerHandler::OnItemsAdded(const int start, const int length) {
-  UpdateResourceGroupTable(start, length);
-
-  // Converts from an index of resources to an index of groups.
-  int group_start = model_->GetGroupIndexForResource(start);
-  int group_end = model_->GetGroupIndexForResource(start + length - 1);
-
-  // First group to add does not contain all the items in the group. Because the
-  // first item to add and the previous one are in same group.
-  if (!model_->IsResourceFirstInGroup(start)) {
-    OnGroupChanged(group_start, 1);
-    if (group_start == group_end)
-      return;
-    else
-      group_start++;
-  }
-
-  // Last group to add does not contain all the items in the group. Because the
-  // last item to add and the next one are in same group.
-  if (!model_->IsResourceLastInGroup(start + length - 1)) {
-    OnGroupChanged(group_end, 1);
-    if (group_start == group_end)
-      return;
-    else
-      group_end--;
-  }
-
-  OnGroupAdded(group_start, group_end - group_start + 1);
 }
 
 void TaskManagerHandler::OnItemsRemoved(const int start, const int length) {
-  // Returns if this is called before updating |resource_to_group_table_|.
-  if (resource_to_group_table_.size() <= static_cast<size_t>(start + length))
-    return;
-
-  // Converts from an index of resources to an index of groups.
-  int group_start = resource_to_group_table_[start];
-  int group_end = resource_to_group_table_[start + length - 1];
-
-  // First group to remove does not contain all the items in the group. Because
-  // the first item to remove and the previous one are in same group.
-  if (start != 0 && group_start == resource_to_group_table_[start - 1]) {
-    OnGroupChanged(group_start, 1);
-    if (group_start == group_end)
-      return;
-    else
-      group_start++;
-  }
-
-  // Last group to remove does not contain all the items in the group. Because
-  // the last item to remove and the next one are in same group.
-  if (start + length != model_->ResourceCount() &&
-      group_end == resource_to_group_table_[start + length]) {
-    OnGroupChanged(group_end, 1);
-    if (group_start == group_end)
-      return;
-    else
-      group_end--;
-  }
-
-  std::vector<int>::iterator it_first =
-      resource_to_group_table_.begin() + start;
-  std::vector<int>::iterator it_last = it_first + length - 1;
-  resource_to_group_table_.erase(it_first, it_last);
-
-  OnGroupRemoved(group_start, group_end - group_start + 1);
 }
 
 void TaskManagerHandler::RegisterMessages() {
@@ -410,6 +331,9 @@ void TaskManagerHandler::EnableTaskManager(const ListValue* indexes) {
     return;
 
   is_enabled_ = true;
+
+  OnGroupChanged(0, model_->GroupCount());
+
   model_->AddObserver(this);
   model_->StartUpdating();
 
@@ -454,22 +378,6 @@ bool TaskManagerHandler::is_alive() {
   return web_ui()->GetWebContents()->GetRenderViewHost() != NULL;
 }
 
-void TaskManagerHandler::UpdateResourceGroupTable(int start, int length) {
-  if (resource_to_group_table_.size() < static_cast<size_t>(start)) {
-    length += start - resource_to_group_table_.size();
-    start = resource_to_group_table_.size();
-  }
-
-  // Makes room to fill group_index at first since inserting vector is too slow.
-  std::vector<int>::iterator it = resource_to_group_table_.begin() + start;
-  resource_to_group_table_.insert(it, static_cast<size_t>(length), -1);
-
-  for (int i = start; i < start + length; ++i) {
-    const int group_index = model_->GetGroupIndexForResource(i);
-    resource_to_group_table_[i] = group_index;
-  }
-}
-
 void TaskManagerHandler::OnGroupChanged(const int group_start,
                                         const int group_length) {
   base::FundamentalValue start_value(group_start);
@@ -488,28 +396,11 @@ void TaskManagerHandler::OnGroupChanged(const int group_start,
 
 void TaskManagerHandler::OnGroupAdded(const int group_start,
                                       const int group_length) {
-  base::FundamentalValue start_value(group_start);
-  base::FundamentalValue length_value(group_length);
-  base::ListValue tasks_value;
-  for (int i = 0; i < group_length; ++i)
-    tasks_value.Append(
-        CreateTaskGroupValue(model_, group_start + i, enabled_columns_));
-
-  if (is_enabled_ && is_alive()) {
-    web_ui()->CallJavascriptFunction("taskAdded",
-                                     start_value, length_value, tasks_value);
-  }
 }
 
 void TaskManagerHandler::OnGroupRemoved(const int group_start,
                                         const int group_length) {
-  base::FundamentalValue start_value(group_start);
-  base::FundamentalValue length_value(group_length);
-  if (is_enabled_ && is_alive())
-    web_ui()->CallJavascriptFunction("taskRemoved", start_value, length_value);
 }
 
 void TaskManagerHandler::OnReadyPeriodicalUpdate() {
-  if (is_enabled_ && is_alive())
-    web_ui()->CallJavascriptFunction("onReadyPeriodicalUpdate");
 }
diff --git a/chrome/browser/ui/webui/task_manager_handler.h b/chrome/browser/ui/webui/task_manager_handler.h
index 52ae4905..f6f5fd6 100644
--- a/chrome/browser/ui/webui/task_manager_handler.h
+++ b/chrome/browser/ui/webui/task_manager_handler.h
@@ -65,9 +65,6 @@ class TaskManagerHandler : public content::WebUIMessageHandler,
 
   bool is_enabled_;
 
-  // Table to cache the group index of the resource index.
-  std::vector<int> resource_to_group_table_;
-
   // Set to store the enabled columns.
   std::set<std::string> enabled_columns_;
 
@@ -77,9 +74,6 @@ class TaskManagerHandler : public content::WebUIMessageHandler,
   void OnGroupChanged(int start, int length);
   void OnGroupRemoved(int start, int length);
 
-  // Updates |resource_to_group_table_|.
-  void UpdateResourceGroupTable(int start, int length);
-
   DISALLOW_COPY_AND_ASSIGN(TaskManagerHandler);
 };