Make old task manager tests work against new task manager.

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 15 matching lines @@
 #include "content/public/common/result_codes.h"
 #include "third_party/WebKit/public/web/WebCache.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "ui/base/models/table_model_observer.h"
 #include "ui/base/text/bytes_formatting.h"
 
 namespace task_management {
 
 namespace {
 
+TaskManagerTableModel* g_instance_for_testing = nullptr;
+
 #if defined(OS_MACOSX)
 // Match Activity Monitor's default refresh rate.
 const int64_t kRefreshTimeMS = 2000;
 
 // Activity Monitor shows %cpu with one decimal digit -- be consistent with
 // that.
 const char kCpuTextFormatString[] = "%.1f";
 #else
 const int64_t kRefreshTimeMS = 1000;
 const char kCpuTextFormatString[] = "%.0f";
@@ skipping 217 matching lines @@
       table_view_delegate_(delegate),
       columns_settings_(new base::DictionaryValue),
       table_model_observer_(nullptr),
       stringifier_(new TaskManagerValuesStringifier),
 #if !defined(DISABLE_NACL)
       is_nacl_debugging_flag_enabled_(base::CommandLine::ForCurrentProcess()->
           HasSwitch(switches::kEnableNaClDebug)) {
 #else
       is_nacl_debugging_flag_enabled_(false) {
 #endif  // !defined(DISABLE_NACL)
+
+  if (!g_instance_for_testing)

[afakhry, 2016/04/28 00:03:13]

That's weird! Can that happen? Can we instantiate a new model while another one
is still being used? Seems like an error not be to ignored.

[ncarter (slow), 2016/05/02 18:33:28]

I've added a comment to g_instance_for_testing describing the assumptions.

The view is a singleton, but there's nothing that prevents the model from having
multiple instances: for example, we were debating instantiating a second model
to drive TaskManagerTesterImpl. Since this is just a testing hook, I didn't want
to impose any limits on the behavior of TaskManagerTableModel or its unittests.
Especially since the model not being a singleton is a nice attribute of the new
task manager.

+    g_instance_for_testing = this;
+
   DCHECK(delegate);
   StartUpdating();
 }
 
 TaskManagerTableModel::~TaskManagerTableModel() {
+  if (g_instance_for_testing == this)
+    g_instance_for_testing = nullptr;
+
   StopUpdating();
 }
 
 int TaskManagerTableModel::RowCount() {
   return static_cast<int>(tasks_.size());
 }
 
 base::string16 TaskManagerTableModel::GetText(int row, int column) {
   if (IsSharedByGroup(column) && !IsTaskFirstInGroup(row))
     return base::string16();
@@ skipping 509 matching lines @@
   }
 }
 
 void TaskManagerTableModel::ToggleColumnVisibility(int column_id) {
   bool new_visibility = !table_view_delegate_->IsColumnVisible(column_id);
   table_view_delegate_->SetColumnVisibility(column_id, new_visibility);
   columns_settings_->SetBoolean(GetColumnIdAsString(column_id), new_visibility);
   UpdateRefreshTypes(column_id, new_visibility);
 }
 
+// static
+TaskManagerTableModel* TaskManagerTableModel::GetInstanceForTesting() {
+  return g_instance_for_testing;
+}
+
 void TaskManagerTableModel::StartUpdating() {
   TaskManagerInterface::GetTaskManager()->AddObserver(this);
   tasks_ = observed_task_manager()->GetTaskIdsList();
   OnRefresh();
 
   // In order for the scrollbar of the TableView to work properly on startup of
   // the task manager, we must invoke TableModelObserver::OnModelChanged() which
   // in turn will invoke TableView::NumRowsChanged(). This will adjust the
   // vertical scrollbar correctly. crbug.com/570966.
   if (table_model_observer_)
@@ skipping 12 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