[Part 3 of 6] Switch ColumnSpecifier to enum class. This makes straddling namespaces easier.

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"
@@ skipping 102 matching lines @@
   // TaskManagerTester:
   int GetRowCount() override { return model_->RowCount(); }
 
   base::string16 GetRowTitle(int row) override {
     return model_->GetText(row, IDS_TASK_MANAGER_TASK_COLUMN);
   }
 
   void ToggleColumnVisibility(ColumnSpecifier column) override {
     int column_id = 0;
     switch (column) {
-      case COLUMN_NONE:
+      case ColumnSpecifier::COLUMN_NONE:
         return;
-      case SQLITE_MEMORY_USED:
+      case ColumnSpecifier::SQLITE_MEMORY_USED:
         column_id = IDS_TASK_MANAGER_SQLITE_MEMORY_USED_COLUMN;
         break;
-      case V8_MEMORY_USED:
-      case V8_MEMORY:
+      case ColumnSpecifier::V8_MEMORY_USED:
+      case ColumnSpecifier::V8_MEMORY:
         column_id = IDS_TASK_MANAGER_JAVASCRIPT_MEMORY_ALLOCATED_COLUMN;
         break;
     }
     model_->ToggleColumnVisibility(column_id);
   }
 
   int64_t GetColumnValue(ColumnSpecifier column, int row) override {
     task_management::TaskId task_id = model_->tasks_[row];
     int64_t value = 0;
     int64_t ignored = 0;
     bool success = false;
 
     switch (column) {
-      case COLUMN_NONE:
+      case ColumnSpecifier::COLUMN_NONE:
         break;
-      case V8_MEMORY:
+      case ColumnSpecifier::V8_MEMORY:
         success = task_manager()->GetV8Memory(task_id, &value, &ignored);
         break;
-      case V8_MEMORY_USED:
+      case ColumnSpecifier::V8_MEMORY_USED:
         success = task_manager()->GetV8Memory(task_id, &ignored, &value);
         break;
-      case SQLITE_MEMORY_USED:
+      case ColumnSpecifier::SQLITE_MEMORY_USED:
         value = task_manager()->GetSqliteMemoryUsed(task_id);
         success = true;
         break;
     }
     if (!success)
       return 0;
     return value;
   }
 
   int32_t GetTabId(int row) override {
@@ skipping 42 matching lines @@
   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 COLUMN_NONE:
+      case ColumnSpecifier::COLUMN_NONE:
         break;
-      case V8_MEMORY:
+      case ColumnSpecifier::V8_MEMORY:
         success = model_->GetV8Memory(row, &value);
         break;
-      case V8_MEMORY_USED:
+      case ColumnSpecifier::V8_MEMORY_USED:
         success = model_->GetV8MemoryUsed(row, &value);
         break;
-      case SQLITE_MEMORY_USED:
+      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
@@ skipping 97 matching lines @@
     }
     return match_count;
   }
 
   int64_t GetColumnValue(int index) {
     return task_manager_tester_->GetColumnValue(column_specifier_, index);
   }
 
   const char* GetColumnName() {
     switch (column_specifier_) {
-      case COLUMN_NONE:
+      case ColumnSpecifier::COLUMN_NONE:
         return "N/A";
-      case V8_MEMORY:
+      case ColumnSpecifier::V8_MEMORY:
         return "V8 Memory";
-      case V8_MEMORY_USED:
+      case ColumnSpecifier::V8_MEMORY_USED:
         return "V8 Memory Used";
-      case SQLITE_MEMORY_USED:
+      case ColumnSpecifier::SQLITE_MEMORY_USED:
         return "SQLite Memory Used";
     }
     return "N/A";
   }
 
   void OnTimeout() {
     base::ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE,
                                                   run_loop_.QuitClosure());
     FAIL() << "Timed out.\n" << DumpTaskManagerModel();
   }
@@ skipping 36 matching lines @@
 std::unique_ptr<TaskManagerTester> GetTaskManagerTester() {
   if (IsNewTaskManagerViewEnabled())
     return base::WrapUnique(new TaskManagerTesterImpl(base::Closure()));
   else
     return base::WrapUnique(new LegacyTaskManagerTesterImpl(base::Closure()));
 }
 
 void WaitForTaskManagerRows(int required_count,
                             const base::string16& title_pattern) {
   const int column_value_dont_care = 0;
-  ResourceChangeObserver observer(required_count, title_pattern, COLUMN_NONE,
+  ResourceChangeObserver observer(required_count, title_pattern,
+                                  ColumnSpecifier::COLUMN_NONE,
                                   column_value_dont_care);
   observer.RunUntilSatisfied();
 }
 
 void WaitForTaskManagerStatToExceed(const base::string16& title_pattern,
                                     ColumnSpecifier column_getter,
                                     size_t min_column_value) {
   const int wait_for_one_match = 1;
   ResourceChangeObserver observer(wait_for_one_match, title_pattern,
                                   column_getter, min_column_value);
@@ skipping 70 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