Add ARC app icons to the Task Manager UI

chrome/browser/memory/tab_manager_delegate_chromeos.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/memory/tab_manager_delegate_chromeos.h"
 
 #include <algorithm>
 #include <set>
 #include <string>
 #include <vector>
@@ skipping 125 matching lines @@
 
 bool IsArcMemoryManagementEnabled() {
   return base::FeatureList::IsEnabled(features::kArcMemoryManagement);
 }
 
 }  // namespace
 
 std::ostream& operator<<(
     std::ostream& out, const TabManagerDelegate::Candidate& candidate) {
   if (candidate.is_arc_app) {
-    out << "app " << candidate.app->pid
-        << " (" << candidate.app->process_name << ")";
+    out << "app " << candidate.app->pid()
+        << " (" << candidate.app->process_name() << ")";
   } else {
     out << "tab " << candidate.tab->renderer_handle;
   }
   out << " with priority " << candidate.priority;
   return out;
 }
 
 // Holds the info of a newly focused tab or app window. The focused process is
 // set to highest priority (lowest OOM score), but not immediately. To avoid
 // redundant settings the OOM score adjusting only happens after a timeout. If
@@ skipping 448 matching lines @@
     const std::vector<arc::ArcProcess>& arc_processes) {
 
   std::vector<Candidate> candidates;
   candidates.reserve(tab_list.size() + arc_processes.size());
 
   for (const auto& tab : tab_list) {
     candidates.push_back(Candidate(&tab, TabStatsToPriority(tab)));
   }
 
   for (const auto& app : arc_processes) {
-    Candidate candidate(&app, AppStateToPriority(app.process_state));
+    Candidate candidate(&app, AppStateToPriority(app.process_state()));
     // Skip persistent android processes since we should never kill them.
     // Also don't ajust OOM score so their score remains min oom_score_adj.
     if (candidate.priority >= ProcessPriority::ANDROID_PERSISTENT)
       continue;
     candidates.push_back(candidate);
   }
 
   // Sort candidates according to priority.
   // TODO(cylee): Missing LRU property. Fix it when apps has the information.
   std::sort(candidates.begin(), candidates.end());
@@ skipping 30 matching lines @@
     // they're in the active window. Since the user experience would be bad.
     if ((!entry.is_arc_app &&
          entry.priority >= ProcessPriority::CHROME_SELECTED) ||
         (entry.is_arc_app &&
          entry.priority >= ProcessPriority::ANDROID_TOP_INACTIVE)) {
       VLOG(2) << "Skipped killing " << entry;
       continue;
     }
     if (entry.is_arc_app) {
         int estimated_memory_freed_kb =
-            mem_stat_->EstimatedMemoryFreedKB(entry.app->pid);
-        if (KillArcProcess(entry.app->nspid)) {
+            mem_stat_->EstimatedMemoryFreedKB(entry.app->pid());
+        if (KillArcProcess(entry.app->nspid())) {
           target_memory_to_free_kb -= estimated_memory_freed_kb;
           uma_->ReportKill(estimated_memory_freed_kb);
           VLOG(2) << "Killed " << entry;
         }
     } else {
       int64_t tab_id = entry.tab->tab_contents_id;
       int estimated_memory_freed_kb =
           mem_stat_->EstimatedMemoryFreedKB(entry.tab->renderer_handle);
       if (KillTab(tab_id)) {
         target_memory_to_free_kb -= estimated_memory_freed_kb;
@@ skipping 96 matching lines @@
   // use up the full range.
   int num = (rend - rbegin);
   const float priority_increment =
       static_cast<float>(range_end - range_begin) / num;
 
   float priority = range_begin;
   for (auto cur = rbegin; cur != rend; ++cur) {
     int score = static_cast<int>(priority + 0.5f);
     if (cur->is_arc_app) {
       // Use pid as map keys so it's globally unique.
-      (*new_map)[cur->app->pid] = score;
+      (*new_map)[cur->app->pid()] = score;
       int cur_app_pid_score = 0;
       {
         base::AutoLock oom_score_autolock(oom_score_lock_);
-        cur_app_pid_score = oom_score_map_[cur->app->pid];
+        cur_app_pid_score = oom_score_map_[cur->app->pid()];
       }
       if (cur_app_pid_score != score) {
         VLOG(3) << "Set OOM score " << score << " for " << *cur;
-        SetOomScoreAdjForApp(cur->app->nspid, score);
+        SetOomScoreAdjForApp(cur->app->nspid(), score);
       }
     } else {
       base::ProcessHandle process_handle = cur->tab->renderer_handle;
       // 1. tab_list contains entries for already-discarded tabs. If the PID
       // (renderer_handle) is zero, we don't need to adjust the oom_score.
       // 2. Only add unseen process handle so if there's multiple tab maps to
       // the same process, the process is set to an OOM score based on its "most
       // important" tab.
       if (process_handle != 0 &&
           new_map->find(process_handle) == new_map->end()) {
@@ skipping 12 matching lines @@
       }
     }
     priority += priority_increment;
   }
 
   if (oom_score_for_tabs.size())
     SetOomScoreAdjForTabs(oom_score_for_tabs);
 }
 
 }  // namespace memory