Fix bug avi found.

chrome/browser/ui/task_manager/task_manager_table_model.cc

Index: chrome/browser/ui/task_manager/task_manager_table_model.cc
diff --git a/chrome/browser/ui/task_manager/task_manager_table_model.cc b/chrome/browser/ui/task_manager/task_manager_table_model.cc
index 76108a6c87a9428c5e79df3f0f4887d327263834..d7bbcd82dd3582092e32e7e0dd34026d871e3e3f 100644
--- a/chrome/browser/ui/task_manager/task_manager_table_model.cc
+++ b/chrome/browser/ui/task_manager/task_manager_table_model.cc
@@ -562,17 +562,20 @@ int TaskManagerTableModel::CompareValues(int row1,
 void TaskManagerTableModel::GetRowsGroupRange(int row_index,
                                               int* out_start,
                                               int* out_length) {
+  base::ProcessId process_id =

[afakhry, 2016/08/01 20:53:53]

const

+      observed_task_manager()->GetProcessId(tasks_[row_index]);
   int i = row_index;
-  for ( ; i >= 0; --i) {
-    if (IsTaskFirstInGroup(i))
-      break;
+  int limit = row_index + 1;
+  while (i > 0 &&
+         observed_task_manager()->GetProcessId(tasks_[i - 1]) == process_id) {
+    i--;

[afakhry, 2016/08/01 20:53:53]

++i?

[Avi (use Gerrit), 2016/08/01 20:57:39]

--i?

[afakhry, 2016/08/01 21:02:59]

Oops, yes, sorry! :)

+  }
+  while (limit < RowCount() &&
+         observed_task_manager()->GetProcessId(tasks_[limit]) == process_id) {
+    limit++;

[afakhry, 2016/08/01 20:53:53]

++limit?

   }
-
-  CHECK_GE(i, 0);
-
   *out_start = i;
-  *out_length = observed_task_manager()->GetNumberOfTasksOnSameProcess(
-      tasks_[row_index]);
+  *out_length = limit - i;

[afakhry, 2016/08/01 20:53:53]

You can ignore the following: :D

Hmmm, that's a very robust and cool fix! But remember Sean Parent? ;)

What you're really trying to do is search forward and backward for the first
task not on the same proc, right?

  const base::ProcessId process_id =
      observed_task_manager()->GetProcessId(tasks_[row_index]);
  auto not_same_proc_pred = [this, process_id](TaskId id) {
    return process_id != observed_task_manager()->GetProcessId(id);
  };

  using iter_t = std::vector<TaskId>::iterator;
  iter_t row_iter = tasks_.begin() + row_index;
  *out_start =
      tasks_.rend() - std::find_if(std::reverse_iterator<iter_t>(row_iter),
                                   tasks_.rend(),
                                   not_same_proc_pred);
  auto end = std::find_if(++row_iter, tasks_.end(), not_same_proc_pred);
  *out_length = end - (tasks_.begin() + *out_start);

[Avi (use Gerrit), 2016/08/01 20:57:39]

Yes, I actually thought of Sean's talk. I searched in <algorithm> for this kind
of thing, but the closest thing was equal_range and that required a sorted span.
By the time you set up two different find_ifs like you did, it didn't feel like
it was worth the hassle.

[afakhry, 2016/08/01 21:02:59]

It's certainly not worth the hassle, that's why I said you can ignore :)

 }
 
 void TaskManagerTableModel::OnTaskAdded(TaskId id) {