Show all system process in the task_manager.

chrome/browser/chromeos/arc/arc_process_service.cc

 // Copyright 2016 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.
 //
 // The main point of this class is to cache ARC proc nspid<->pid mapping
 // globally. Since the calculation is costly, a dedicated worker thread is
 // used. All read/write of its internal data structure (i.e., the mapping)
 // should be on this thread.
 
 #include "chrome/browser/chromeos/arc/arc_process_service.h"
 
 #include <queue>
 #include <set>
 #include <string>
 
+#include "base/callback_forward.h"
 #include "base/process/process.h"
 #include "base/process/process_iterator.h"
 #include "base/task_runner_util.h"
 #include "base/trace_event/trace_event.h"
 #include "content/public/browser/browser_thread.h"
 
 namespace arc {
 
 namespace {
 
-const char kSequenceToken[] = "arc_process_service";
+constexpr char kSequenceToken[] = "arc_process_service";
 
 // Weak pointer.  This class is owned by ArcServiceManager.
 ArcProcessService* g_arc_process_service = nullptr;
 
 }  // namespace
 
 using base::kNullProcessId;
 using base::Process;
 using base::ProcessId;
 using base::SequencedWorkerPool;
@@ skipping 33 matching lines @@
       FROM_HERE,
       base::Bind(&ArcProcessService::Reset,
                  weak_ptr_factory_.GetWeakPtr()));
 }
 
 void ArcProcessService::Reset() {
   DCHECK(thread_checker_.CalledOnValidThread());
   nspid_to_pid_.clear();
 }
 
-bool ArcProcessService::RequestProcessList(
+void ArcProcessService::PostTaskToOwnThreadAndReply(
+    const base::Closure& task,
+    const base::Closure& reply) {
+  auto runner = worker_pool_->GetSequencedTaskRunner(
+      worker_pool_->GetNamedSequenceToken(kSequenceToken));
+  runner->PostTaskAndReply(FROM_HERE, task, reply);
+}
+
+void ArcProcessService::RequestSystemProcessList(
     RequestProcessListCallback callback) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
 
+  auto ret_processes = new vector<ArcProcess>();
+  PostTaskToOwnThreadAndReply(
+      base::Bind(&ArcProcessService::GetArcSystemProcessList,
+                 weak_ptr_factory_.GetWeakPtr(),
+                 base::Unretained(ret_processes)),
+      base::Bind(&ArcProcessService::CallbackRelay,
+                 weak_ptr_factory_.GetWeakPtr(), callback,
+                 base::Owned(ret_processes)));
+}
+
+void ArcProcessService::GetArcSystemProcessList(
+    vector<ArcProcess>* ret_processes) {
+  DCHECK(thread_checker_.CalledOnValidThread());
+
+  const base::ProcessIterator::ProcessEntries& entry_list =
+      base::ProcessIterator(nullptr).Snapshot();
+  ProcessId arc_init_pid = GetArcInitProcessId(entry_list);
+
+  if (arc_init_pid == kNullProcessId) {
+    return;
+  }
+
+  // Enumerate the child processes of ARC init for gathering ARC System
+  // Procceses
+  for (const base::ProcessEntry& entry : entry_list) {
+    // TODO(hctsai): For now, we only gather direct child process of init, need
+    //               to get the processes below.
+    if (entry.parent_pid() == arc_init_pid) {
+      ProcessId child_pid = entry.pid();
+      ProcessId child_nspid = base::Process(child_pid).GetPidInNamespace();
+      std::string process_name =
+          !entry.cmd_line_args().empty() ? entry.cmd_line_args()[0] : "";
+      if (child_nspid != kNullProcessId) {
+        ArcProcess arc_process(child_nspid, child_pid, process_name,
+                               mojom::ProcessState::PERSISTENT);
+        ret_processes->push_back(std::move(arc_process));
+      }
+    }
+  }
+}
+
+bool ArcProcessService::RequestAppProcessList(
+    RequestProcessListCallback callback) {
+  DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
+
   arc::mojom::ProcessInstance* process_instance =
       arc_bridge_service()->process_instance();
   if (!process_instance) {
     return false;
   }
   process_instance->RequestProcessList(
       base::Bind(&ArcProcessService::OnReceiveProcessList,
                  weak_ptr_factory_.GetWeakPtr(),
                  callback));
   return true;
@@ skipping 10 matching lines @@
   auto ret_processes = new vector<ArcProcess>();
   // Post to its dedicated worker thread to avoid race condition.
   // Since no two tasks with the same token should be run at the same.
   // Note: GetSequencedTaskRunner's shutdown behavior defaults to
   // SKIP_ON_SHUTDOWN (ongoing task blocks shutdown).
   // So in theory using Unretained(this) should be fine since the life cycle
   // of |this| is the same as the main browser.
   // To be safe I still use weak pointers, but weak_ptrs can only bind to
   // methods without return values. That's why I can't use
   // PostTaskAndReplyWithResult but handle the return object by myself.
-  auto runner = worker_pool_->GetSequencedTaskRunner(
-      worker_pool_->GetNamedSequenceToken(kSequenceToken));
-  runner->PostTaskAndReply(
-      FROM_HERE,
+  PostTaskToOwnThreadAndReply(
       base::Bind(&ArcProcessService::UpdateAndReturnProcessList,
-                 weak_ptr_factory_.GetWeakPtr(),
-                 base::Owned(raw_processes),
+                 weak_ptr_factory_.GetWeakPtr(), base::Owned(raw_processes),
                  base::Unretained(ret_processes)),
       base::Bind(&ArcProcessService::CallbackRelay,
-                 weak_ptr_factory_.GetWeakPtr(),
-                 callback,
+                 weak_ptr_factory_.GetWeakPtr(), callback,
                  base::Owned(ret_processes)));
 }
 
 void ArcProcessService::CallbackRelay(
     const RequestProcessListCallback& callback,
     const vector<ArcProcess>* ret_processes) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
   callback.Run(*ret_processes);
 }
 
@@ skipping 66 matching lines @@
   // processes may have the same nspid. We need to get the proper subset of
   // processes to create correct nspid -> pid map.
 
   // Construct the process tree.
   // NB: This can contain a loop in case of race conditions.
   map<ProcessId, vector<ProcessId> > process_tree;
   for (const base::ProcessEntry& entry : entry_list)
     process_tree[entry.parent_pid()].push_back(entry.pid());
 
   // Find the ARC init process.
-  ProcessId arc_init_pid = kNullProcessId;
-  for (const base::ProcessEntry& entry : entry_list) {
-    // TODO(nya): Add more constraints to avoid mismatches.
-    std::string process_name =
-        !entry.cmd_line_args().empty() ? entry.cmd_line_args()[0] : "";
-    if (process_name == "/init") {
-      arc_init_pid = entry.pid();
-      break;
-    }
-  }
+  ProcessId arc_init_pid = GetArcInitProcessId(entry_list);
 
   // Enumerate all processes under ARC init and create nspid -> pid map.
   if (arc_init_pid != kNullProcessId) {
     std::queue<ProcessId> queue;
     std::set<ProcessId> visited;
     queue.push(arc_init_pid);
     while (!queue.empty()) {
       ProcessId pid = queue.front();
       queue.pop();
       // Do not visit the same process twice. Otherwise we may enter an infinite
@@ skipping 10 matching lines @@
       if (nspid != kNullProcessId &&
           nspid_to_pid_.find(nspid) != nspid_to_pid_.end())
         nspid_to_pid_[nspid] = pid;
 
       for (ProcessId child_pid : process_tree[pid])
         queue.push(child_pid);
     }
   }
 }
 
+// static
+ProcessId ArcProcessService::GetArcInitProcessId(
+    const base::ProcessIterator::ProcessEntries& entry_list) {
+  // Find the ARC init process.
+  for (const base::ProcessEntry& entry : entry_list) {
+    // TODO(nya): Add more constraints to avoid mismatches.
+    std::string process_name =
+        !entry.cmd_line_args().empty() ? entry.cmd_line_args()[0] : "";
+    if (process_name == "/init") {
+      return entry.pid();
+    }
+  }
+  return kNullProcessId;
+}
+
 }  // namespace arc