[Part 4 of 6] Split LegacyTaskManagerTester into its own file.

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/bind_helpers.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_manager/legacy_task_manager_tester.h"
 #include "chrome/browser/task_manager/resource_provider.h"
 #include "chrome/browser/task_manager/task_manager.h"
 #include "chrome/browser/ui/browser_dialogs.h"
 #include "chrome/browser/ui/task_manager/task_manager_table_model.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"
 #include "ui/base/models/table_model_observer.h"
@@ skipping 145 matching lines @@
             chrome::ShowTaskManager(nullptr));
     return result;
   }
 
   task_management::TaskManagerTableModel* model_;
   std::unique_ptr<ScopedInterceptTableModelObserver> interceptor_;
 };
 
 namespace {
 
-class LegacyTaskManagerTesterImpl : public TaskManagerTester,
-                                    public TaskManagerModelObserver {
- public:
-  explicit LegacyTaskManagerTesterImpl(const base::Closure& on_resource_change)
-      : on_resource_change_(on_resource_change),
-        model_(TaskManager::GetInstance()->model()) {
-    if (!on_resource_change_.is_null())
-      model_->AddObserver(this);
-  }
-  ~LegacyTaskManagerTesterImpl() override {
-    if (!on_resource_change_.is_null())
-      model_->RemoveObserver(this);
-  }
-
-  // TaskManagerTester:
-  int GetRowCount() override { return model_->ResourceCount(); }
-
-  base::string16 GetRowTitle(int row) override {
-    return model_->GetResourceTitle(row);
-  }
-
-  int64_t GetColumnValue(ColumnSpecifier column, int row) override {
-    size_t value = 0;
-    bool success = false;
-    switch (column) {
-      case ColumnSpecifier::COLUMN_NONE:
-        break;
-      case ColumnSpecifier::V8_MEMORY:
-        success = model_->GetV8Memory(row, &value);
-        break;
-      case ColumnSpecifier::V8_MEMORY_USED:
-        success = model_->GetV8MemoryUsed(row, &value);
-        break;
-      case ColumnSpecifier::SQLITE_MEMORY_USED:
-        success = model_->GetSqliteMemoryUsedBytes(row, &value);
-        break;
-    }
-    if (!success)
-      return 0;
-    return static_cast<int64_t>(value);
-  }
-
-  void ToggleColumnVisibility(ColumnSpecifier column) override {
-    // Doing nothing is okay here; the legacy TaskManager always collects all
-    // stats.
-  }
-
-  int32_t GetTabId(int row) override {
-    if (model_->GetResourceWebContents(row)) {
-      return SessionTabHelper::IdForTab(model_->GetResourceWebContents(row));
-    }
-    return -1;
-  }
-
-  void Kill(int row) override { 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() {
-    if (!on_resource_change_.is_null())
-      on_resource_change_.Run();
-  }
-  base::Closure on_resource_change_;
-  TaskManagerModel* model_;
-};
-
 // Helper class to run a message loop until a TaskManagerTester is in an
 // expected state. If timeout occurs, an ASCII version of the task manager's
 // contents, along with a summary of the expected state, are dumped to test
 // output, to assist debugging.
 class ResourceChangeObserver {
  public:
   ResourceChangeObserver(int required_count,
                          const base::string16& title_pattern,
                          ColumnSpecifier column_specifier,
                          size_t min_column_value)
       : required_count_(required_count),
         title_pattern_(title_pattern),
         column_specifier_(column_specifier),
         min_column_value_(min_column_value) {
     base::Closure callback = base::Bind(
         &ResourceChangeObserver::OnResourceChange, base::Unretained(this));
 
     if (IsNewTaskManagerViewEnabled())
       task_manager_tester_.reset(new TaskManagerTesterImpl(callback));
     else
-      task_manager_tester_.reset(new LegacyTaskManagerTesterImpl(callback));
+      task_manager_tester_ = LegacyTaskManagerTester::Create(callback);
   }
 
   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(), this,
@@ skipping 96 matching lines @@
   base::RunLoop run_loop_;
   base::OneShotTimer timer_;
 };
 
 }  // namespace
 
 std::unique_ptr<TaskManagerTester> GetTaskManagerTester() {
   if (IsNewTaskManagerViewEnabled())
     return base::WrapUnique(new TaskManagerTesterImpl(base::Closure()));
   else
-    return base::WrapUnique(new LegacyTaskManagerTesterImpl(base::Closure()));
+    return LegacyTaskManagerTester::Create(base::Closure());

[afakhry, 2016/05/07 00:16:09]

I just noticed this. There's a code duplication between here and
ResourceChangeObserver() ctor.

Can we dedup and make GetTaskManagerTester() take a closure, and use in the
ResourceChangeObserver() ctor to set the |task_manager_tester_|?

Who else uses GetTaskManagerTester()?

[ncarter (slow), 2016/05/07 22:29:08]

Your suggestion is implemented happens in PS5. And yes, originally it seemed
like it made sense to hide the callback, but there's only one caller, so it's no
big deal in practice.

 }
 
 void WaitForTaskManagerRows(int required_count,
                             const base::string16& title_pattern) {
   const int column_value_dont_care = 0;
   ResourceChangeObserver observer(required_count, title_pattern,
                                   ColumnSpecifier::COLUMN_NONE,
                                   column_value_dont_care);
   observer.RunUntilSatisfied();
 }
@@ skipping 77 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