Reland "arc-bridge: Move most methods to Mojo interfaces"

chrome/browser/task_management/providers/arc/arc_process_task_provider.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/task_management/providers/arc/arc_process_task_provider.h"
 
 #include <queue>
 #include <set>
 #include <utility>
 #include <vector>
@@ skipping 63 matching lines @@
         queue.push(child_pid);
     }
   }
   return nspid_to_pid;
 }
 
 }  // namespace
 
 namespace task_management {
 
-ArcProcessTaskProvider::ArcProcessTaskProvider()
-    : weak_ptr_factory_(this) {
-}
+ArcProcessTaskProvider::ArcProcessTaskProvider() : weak_ptr_factory_(this) {}
 
-ArcProcessTaskProvider::~ArcProcessTaskProvider() {
-}
+ArcProcessTaskProvider::~ArcProcessTaskProvider() {}
 
 Task* ArcProcessTaskProvider::GetTaskOfUrlRequest(int origin_pid,
                                                   int child_id,
                                                   int route_id) {
   // ARC tasks are not associated with any URL request.
   return nullptr;
 }
 
 void ArcProcessTaskProvider::OnUpdateProcessList(
-    const std::vector<arc::RunningAppProcessInfo>& processes) {
+    mojo::Array<arc::RunningAppProcessInfoPtr> processes) {
   TRACE_EVENT0("browser", "ArcProcessTaskProvider::OnUpdateProcessList");
 
   // NB: |processes| can be already stale here because it is sent via IPC, and
   // we can never avoid that. See also the comment at the declaration of
   // ArcProcessTaskProvider.
 
   std::vector<arc::RunningAppProcessInfo> added_processes;
   std::set<base::ProcessId> removed_nspids;
   for (const auto& entry : nspid_to_task_)
     removed_nspids.insert(entry.first);
-  for (const arc::RunningAppProcessInfo& process : processes) {
-    if (nspid_to_task_.count(process.pid))
-      removed_nspids.erase(process.pid);
+  for (size_t i = 0; i < processes.size(); ++i) {
+    const arc::RunningAppProcessInfoPtr& process = processes[i];
+    if (nspid_to_task_.count(process->pid))
+      removed_nspids.erase(process->pid);
     else
-      added_processes.push_back(process);
+      added_processes.push_back(*process);
   }
 
   // Remove stale tasks.
   RemoveTasks(removed_nspids);
 
   // Add new tasks.
   // Note: ComputeNspidToPidMap() is an expensive operation, so try to reduce
   // the number of times it is called.
   if (!added_processes.empty()) {
     base::PostTaskAndReplyWithResult(
         base::WorkerPool::GetTaskRunner(false /* task_is_slow */).get(),
         FROM_HERE,
         base::Bind(&ComputeNspidToPidMap),
         base::Bind(&ArcProcessTaskProvider::AddTasks,
                    weak_ptr_factory_.GetWeakPtr(),
                    added_processes));
   }
 }
 
 void ArcProcessTaskProvider::RequestProcessList() {
-  arc::ArcBridgeService::Get()->RequestProcessList();
+  arc::ProcessInstance* arc_process_instance =
+      arc::ArcBridgeService::Get()->process_instance();
+  if (!arc_process_instance) {
+    VLOG(2) << "ARC process instance is not ready.";
+    return;
+  }
+  arc_process_instance->RequestProcessList(
+      base::Bind(&ArcProcessTaskProvider::OnUpdateProcessList,
+                 weak_ptr_factory_.GetWeakPtr()));
 }
 
 void ArcProcessTaskProvider::RemoveTasks(
     const std::set<base::ProcessId>& removed_nspids) {
   for (base::ProcessId nspid : removed_nspids) {
     NotifyObserverTaskRemoved(nspid_to_task_[nspid].get());
     nspid_to_task_.erase(nspid);
   }
 }
 
 void ArcProcessTaskProvider::AddTasks(
     const std::vector<arc::RunningAppProcessInfo>& added_processes,
     const std::map<base::ProcessId, base::ProcessId>& nspid_to_pid) {
   for (const arc::RunningAppProcessInfo& process : added_processes) {
     auto iter = nspid_to_pid.find(process.pid);
     if (iter == nspid_to_pid.end()) {
       // The process may have exited just after the snapshot was generated.
       continue;
     }
     base::ProcessId pid = iter->second;
     scoped_ptr<ArcProcessTask>& task = nspid_to_task_[process.pid];
     task.reset(new ArcProcessTask(pid, process.pid, process.process_name));
     NotifyObserverTaskAdded(task.get());
   }
 }
 
 void ArcProcessTaskProvider::StartUpdating() {
-  arc::ArcBridgeService::Get()->AddProcessObserver(this);
   RequestProcessList();
   // TODO(nya): Remove this timer once ARC starts to send us UpdateProcessList
   // message when the process list changed. As of today, ARC does not send
   // the process list unless we request it by RequestProcessList message.
   timer_.Start(
       FROM_HERE,
       base::TimeDelta::FromSeconds(1),
       this,
       &ArcProcessTaskProvider::RequestProcessList);
 }
 
 void ArcProcessTaskProvider::StopUpdating() {
-  arc::ArcBridgeService::Get()->RemoveProcessObserver(this);
   timer_.Stop();
   nspid_to_task_.clear();
 }
 
 }  // namespace task_management