Fix bug avi found.

chrome/browser/ui/task_manager/task_manager_table_model.cc

 // 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.
 
 #include "chrome/browser/ui/task_manager/task_manager_table_model.h"
 
 #include <stddef.h>
 
 #include "base/command_line.h"
 #include "base/i18n/number_formatting.h"
@@ skipping 544 matching lines @@
 
     default:
       NOTREACHED();
       return 0;
   }
 }
 
 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! :)

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

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

++limit?

+  }
   *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) {
   // For the table view scrollbar to behave correctly we must inform it that
   // a new task has been added.
 
   // We will get a newly sorted list from the task manager as opposed to just
   // adding |id| to |tasks_| because we want to keep |tasks_| sorted by proc IDs
   // and then by Task IDs.
   tasks_ = observed_task_manager()->GetTaskIdsList();
@@ skipping 246 matching lines @@
 bool TaskManagerTableModel::IsTaskFirstInGroup(int row_index) const {
   if (row_index == 0)
     return true;
 
   return observed_task_manager()->GetProcessId(tasks_[row_index - 1]) !=
       observed_task_manager()->GetProcessId(tasks_[row_index]);
 }
 
 
 }  // namespace task_management