Make old task manager tests work against new task manager.

chrome/browser/task_manager/task_manager_browsertest_util.cc

 // Copyright (c) 2012 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/task_manager/task_manager_browsertest_util.h"
 
 #include "base/command_line.h"
 #include "base/location.h"
+#include "base/memory/ptr_util.h"
 #include "base/run_loop.h"
 #include "base/single_thread_task_runner.h"
 #include "base/strings/pattern.h"
 #include "base/strings/string16.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/test/test_timeouts.h"
 #include "base/thread_task_runner_handle.h"
 #include "base/timer/timer.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/profiles/profile.h"
+#include "chrome/browser/sessions/session_tab_helper.h"
+#include "chrome/browser/task_management/task_manager_interface.h"
+#include "chrome/browser/task_management/task_manager_observer.h"
 #include "chrome/browser/task_manager/resource_provider.h"
 #include "chrome/browser/task_manager/task_manager.h"
+#include "chrome/browser/ui/task_manager/task_manager_table_model.h"
+#include "chrome/browser/ui/views/new_task_manager_view.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/grit/generated_resources.h"
 #include "extensions/strings/grit/extensions_strings.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "ui/base/l10n/l10n_util.h"
 
+namespace task_management {
+
+class TaskManagerTester
+    : public task_manager::browsertest_util::TaskManagerTesterInterface,
+      public TaskManagerObserver {
+ public:
+  explicit TaskManagerTester(const base::Closure& on_resource_change)
+      : TaskManagerObserver(NewTaskManagerView::GetInstanceForTests()
+                                ->table_model_->desired_refresh_time(),
+                            NewTaskManagerView::GetInstanceForTests()
+                                ->table_model_->desired_resources_flags()),
+        on_resource_change_(on_resource_change),
+        model_(NewTaskManagerView::GetInstanceForTests()->table_model_.get()) {}
+
+  virtual int GetRowCount() { return model_->RowCount(); }
+
+  virtual base::string16 GetRowTitle(int row) {
+    return model_->GetText(row, IDS_TASK_MANAGER_TASK_COLUMN);
+  }
+
+  virtual int64_t GetColumnValue(
+      task_manager::browsertest_util::ColumnSpecifier column,
+      int row) {
+    TaskId task_id = model_->tasks_[row];
+    int64_t value = 0;
+    int64_t ignored = 0;
+    bool success = false;
+
+    switch (column) {
+      case task_manager::browsertest_util::COLUMN_NONE:
+        break;
+      case task_manager::browsertest_util::V8_MEMORY:
+        success =
+            observed_task_manager()->GetV8Memory(task_id, &value, &ignored);
+        break;
+      case task_manager::browsertest_util::V8_MEMORY_USED:
+        success =
+            observed_task_manager()->GetV8Memory(task_id, &ignored, &value);
+        break;
+      case task_manager::browsertest_util::SQLITE_MEMORY_USED:
+        value = observed_task_manager()->GetSqliteMemoryUsed(task_id);
+        success = true;
+        break;
+    }
+    if (!success)
+      return 0;
+    return value;
+  }
+
+  virtual int32_t GetTabId(int row) {
+    TaskId task_id = model_->tasks_[row];
+    return observed_task_manager()->GetTabId(task_id);
+  }
+
+  virtual void Kill(int row) { model_->KillTask(row); }
+
+  // TaskManagerObserver
+  void OnTaskAdded(TaskId id) { on_resource_change_.Run(); }
+
+  void OnTaskToBeRemoved(TaskId id) { on_resource_change_.Run(); }
+
+  void OnTasksRefreshed(const TaskIdList& task_ids) {
+    on_resource_change_.Run();
+  }
+
+  void OnTasksRefreshedWithBackgroundCalculations(const TaskIdList& task_ids) {
+    on_resource_change_.Run();
+  }
+
+  void OnTaskUnresponsive(TaskId id) { on_resource_change_.Run(); }
+
+ private:
+  base::Closure on_resource_change_;
+  TaskManagerTableModel* model_;
+};
+
+}  // namespace task_management
+
 namespace task_manager {
 namespace browsertest_util {
 
 namespace {
 
-class ResourceChangeObserver : public TaskManagerModelObserver {
+class OldTaskManagerTester : public TaskManagerTesterInterface,
+                             public TaskManagerModelObserver {
  public:
-  ResourceChangeObserver(const TaskManagerModel* model,
-                         int required_count,
+  explicit OldTaskManagerTester(const base::Closure& on_resource_change)
+      : on_resource_change_(on_resource_change),
+        model_(TaskManager::GetInstance()->model()) {
+    model_->AddObserver(this);
+  }
+  ~OldTaskManagerTester() { model_->RemoveObserver(this); }
+
+  // TaskManagerTesterInterface:
+  virtual int GetRowCount() { return model_->ResourceCount(); }
+
+  virtual base::string16 GetRowTitle(int row) {
+    return model_->GetResourceTitle(row);
+  }
+
+  virtual int64_t GetColumnValue(ColumnSpecifier column, int row) {
+    size_t value = 0;
+    bool success = false;
+    switch (column) {
+      case COLUMN_NONE:
+        break;
+      case V8_MEMORY:
+        success = model_->GetV8Memory(row, &value);
+        break;
+      case V8_MEMORY_USED:
+        success = model_->GetV8MemoryUsed(row, &value);
+        break;
+      case SQLITE_MEMORY_USED:
+        success = model_->GetSqliteMemoryUsedBytes(row, &value);
+        break;
+    }
+    if (!success)
+      return 0;
+    return static_cast<int64_t>(value);
+  }
+
+  virtual int32_t GetTabId(int row) {
+    if (model_->GetResourceWebContents(row)) {
+      return SessionTabHelper::IdForTab(model_->GetResourceWebContents(row));
+    }
+    return -1;
+  }
+
+  virtual void Kill(int row) { TaskManager::GetInstance()->KillProcess(row); }
+
+  // TaskManagerModelObserver:
+  void OnModelChanged() override { OnResourceChange(); }
+  void OnItemsChanged(int start, int length) override { OnResourceChange(); }
+  void OnItemsAdded(int start, int length) override { OnResourceChange(); }
+  void OnItemsRemoved(int start, int length) override { OnResourceChange(); }
+
+ private:
+  void OnResourceChange() { on_resource_change_.Run(); }
+  base::Closure on_resource_change_;
+  TaskManagerModel* model_;
+};
+
+class ResourceChangeObserver {
+ public:
+  ResourceChangeObserver(int required_count,
                          const base::string16& title_pattern,
                          ColumnSpecifier column_specifier,
                          size_t min_column_value)
-      : model_(model),
-        required_count_(required_count),
+      : required_count_(required_count),
         title_pattern_(title_pattern),
         column_specifier_(column_specifier),
-        min_column_value_(min_column_value) {}
+        min_column_value_(min_column_value) {
+    base::Closure on_resource_change = base::Bind(
+        &ResourceChangeObserver::OnResourceChange, base::Unretained(this));
 
-  void OnModelChanged() override { OnResourceChange(); }
-
-  void OnItemsChanged(int start, int length) override { OnResourceChange(); }
-
-  void OnItemsAdded(int start, int length) override { OnResourceChange(); }
-
-  void OnItemsRemoved(int start, int length) override { OnResourceChange(); }
+    if (switches::NewTaskManagerEnabled()) {
+      model_.reset(new task_management::TaskManagerTester(on_resource_change));
+    } else {
+      model_.reset(new OldTaskManagerTester(on_resource_change));
+    }
+  }
 
   void RunUntilSatisfied() {
     // See if the condition is satisfied without having to run the loop. This
     // check has to be placed after the installation of the
     // TaskManagerModelObserver, because resources may change before that.
     if (IsSatisfied())
       return;
 
     timer_.Start(FROM_HERE,
                  TestTimeouts::action_timeout(),
@@ skipping 10 matching lines @@
       FAIL() << "Wait condition satisfied only emphemerally. Likely test "
              << "problem. Maybe wait instead for the state below?\n"
              << DumpTaskManagerModel();
     }
 
     timer_.Stop();
   }
 
  private:
   void OnResourceChange() {
+    DLOG(INFO) << DumpTaskManagerModel();
     if (!IsSatisfied())
       return;
 
     base::ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE,
                                                   run_loop_.QuitClosure());
   }
 
   bool IsSatisfied() { return CountMatches() == required_count_; }
 
   int CountMatches() {
     int match_count = 0;
-    for (int i = 0; i < model_->ResourceCount(); i++) {
-      if (!base::MatchPattern(model_->GetResourceTitle(i), title_pattern_))
+    for (int i = 0; i < model_->GetRowCount(); i++) {
+      if (!base::MatchPattern(model_->GetRowTitle(i), title_pattern_))
         continue;
 
       if (GetColumnValue(i) < min_column_value_)
         continue;
 
       match_count++;
     }
     return match_count;
   }
 
-  size_t GetColumnValue(int index) {
-    size_t value = 0;
-    bool success = false;
-    switch (column_specifier_) {
-      case COLUMN_NONE:
-        break;
-      case V8_MEMORY:
-        success = model_->GetV8Memory(index, &value);
-        break;
-      case V8_MEMORY_USED:
-        success = model_->GetV8MemoryUsed(index, &value);
-        break;
-      case SQLITE_MEMORY_USED:
-        success = model_->GetSqliteMemoryUsedBytes(index, &value);
-        break;
-    }
-    if (!success)
-      return 0;
-    return value;
+  int64_t GetColumnValue(int index) {
+    return model_->GetColumnValue(column_specifier_, index);
   }
 
   const char* GetColumnName() {
     switch (column_specifier_) {
       case COLUMN_NONE:
         return "N/A";
       case V8_MEMORY:
         return "V8 Memory";
       case V8_MEMORY_USED:
         return "V8 Memory Used";
@@ skipping 14 matching lines @@
     task_manager_state_dump << "Waiting for exactly " << required_count_
                             << " matches of wildcard pattern \""
                             << base::UTF16ToASCII(title_pattern_) << "\"";
     if (min_column_value_ > 0) {
       task_manager_state_dump << " && [" << GetColumnName()
                               << " >= " << min_column_value_ << "]";
     }
     task_manager_state_dump << "\nCurrently there are " << CountMatches()
                             << " matches.";
     task_manager_state_dump << "\nCurrent Task Manager Model is:";
-    for (int i = 0; i < model_->ResourceCount(); i++) {
-      task_manager_state_dump
-          << "\n  > " << std::setw(40) << std::left
-          << base::UTF16ToASCII(model_->GetResourceTitle(i));
+    for (int i = 0; i < model_->GetRowCount(); i++) {
+      task_manager_state_dump << "\n  > " << std::setw(40) << std::left
+                              << base::UTF16ToASCII(model_->GetRowTitle(i));
       if (min_column_value_ > 0) {
         task_manager_state_dump << " [" << GetColumnName()
                                 << " == " << GetColumnValue(i) << "]";
       }
     }
     return task_manager_state_dump;
   }
 
-  const TaskManagerModel* model_;
+  scoped_ptr<TaskManagerTesterInterface> model_;
   const int required_count_;
   const base::string16 title_pattern_;
   const ColumnSpecifier column_specifier_;
-  const size_t min_column_value_;
+  const int64_t min_column_value_;
   base::RunLoop run_loop_;
   base::OneShotTimer timer_;
 };
 
 }  // namespace
 
-void EnableOldTaskManager() {
-  base::CommandLine::ForCurrentProcess()->AppendSwitch(
-      switches::kDisableNewTaskManager);
+std::unique_ptr<TaskManagerTesterInterface> GetTaskManagerTester() {
+  if (switches::NewTaskManagerEnabled()) {
+    return base::WrapUnique(
+        new task_management::TaskManagerTester(base::Closure()));
+  } else {
+    return base::WrapUnique(new OldTaskManagerTester(base::Closure()));
+  }
 }
 
 void WaitForTaskManagerRows(int required_count,
                             const base::string16& title_pattern) {
-  TaskManagerModel* model = TaskManager::GetInstance()->model();
-
   const int column_value_dont_care = 0;
-  ResourceChangeObserver observer(model, required_count, title_pattern,
-                                  COLUMN_NONE, column_value_dont_care);
-  model->AddObserver(&observer);
+  ResourceChangeObserver observer(required_count, title_pattern, COLUMN_NONE,
+                                  column_value_dont_care);
   observer.RunUntilSatisfied();
-  model->RemoveObserver(&observer);
 }
 
 void WaitForTaskManagerStatToExceed(const base::string16& title_pattern,
                                     ColumnSpecifier column_getter,
                                     size_t min_column_value) {
-  TaskManagerModel* model = TaskManager::GetInstance()->model();
-
   const int wait_for_one_match = 1;
-  ResourceChangeObserver observer(model, wait_for_one_match, title_pattern,
+  ResourceChangeObserver observer(wait_for_one_match, title_pattern,
                                   column_getter, min_column_value);
-  model->AddObserver(&observer);
   observer.RunUntilSatisfied();
-  model->RemoveObserver(&observer);
 }
 
 base::string16 MatchTab(const char* title) {
   return l10n_util::GetStringFUTF16(IDS_TASK_MANAGER_TAB_PREFIX,
                                     base::ASCIIToUTF16(title));
 }
 
 base::string16 MatchAnyTab() { return MatchTab("*"); }
 
 base::string16 MatchAboutBlankTab() { return MatchTab("about:blank"); }
@@ skipping 46 matching lines @@
 base::string16 MatchUtility(const base::string16& title) {
   return l10n_util::GetStringFUTF16(IDS_TASK_MANAGER_UTILITY_PREFIX, title);
 }
 
 base::string16 MatchAnyUtility() {
   return MatchUtility(base::ASCIIToUTF16("*"));
 }
 
 }  // namespace browsertest_util
 }  // namespace task_manager