arc: Convert more Mojo types to STL

chrome/browser/chromeos/arc/process/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/process/arc_process_service.h"
@@ skipping 123 matching lines @@
         (*pid_map)[nspid] = pid;
 
       for (ProcessId child_pid : process_tree[pid])
         queue.push(child_pid);
     }
   }
 }
 
 std::vector<ArcProcess> FilterProcessList(
     const ArcProcessService::NSPidToPidMap& pid_map,
-    mojo::Array<mojom::RunningAppProcessInfoPtr> processes) {
+    std::vector<mojom::RunningAppProcessInfoPtr> processes) {
   std::vector<ArcProcess> ret_processes;
   for (const auto& entry : processes) {
     const auto it = pid_map.find(entry->pid);
     // The nspid could be missing due to race condition. For example, the
     // process is still running when we get the process snapshot and ends when
     // we update the nspid to pid mapping.
     if (it == pid_map.end() || it->second == base::kNullProcessId) {
       continue;
     }
     // Constructs the ArcProcess instance if the mapping is found.
     ArcProcess arc_process(entry->pid, pid_map.at(entry->pid),
                            entry->process_name, entry->process_state,
                            entry->is_focused, entry->last_activity_time);
     // |entry->packages| is provided only when process.mojom's verion is >=4.
     if (entry->packages) {
-      for (const auto& package : entry->packages) {
-        arc_process.packages().push_back(package.get());
+      for (const auto& package : *entry->packages) {
+        arc_process.packages().push_back(package);
       }
     }
     ret_processes.push_back(std::move(arc_process));
   }
   return ret_processes;
 }
 
 std::vector<ArcProcess> UpdateAndReturnProcessList(
     scoped_refptr<ArcProcessService::NSPidToPidMap> nspid_map,
-    mojo::Array<mojom::RunningAppProcessInfoPtr> processes) {
+    std::vector<mojom::RunningAppProcessInfoPtr> processes) {
   ArcProcessService::NSPidToPidMap& pid_map = *nspid_map;
   // Cleanup dead pids in the cache |pid_map|.
   std::unordered_set<ProcessId> nspid_to_remove;
   for (const auto& entry : pid_map) {
     nspid_to_remove.insert(entry.first);
   }
   bool unmapped_nspid = false;
   for (const auto& entry : processes) {
     // erase() returns 0 if coudln't find the key. It means a new process.
     if (nspid_to_remove.erase(entry->pid) == 0) {
@@ skipping 70 matching lines @@
     return false;
   }
   process_instance->RequestProcessList(
       base::Bind(&ArcProcessService::OnReceiveProcessList,
                  weak_ptr_factory_.GetWeakPtr(), callback));
   return true;
 }
 
 void ArcProcessService::OnReceiveProcessList(
     const RequestProcessListCallback& callback,
-    mojo::Array<mojom::RunningAppProcessInfoPtr> instance_processes) {
+    std::vector<mojom::RunningAppProcessInfoPtr> instance_processes) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
 
   base::PostTaskAndReplyWithResult(
       GetTaskRunner().get(), FROM_HERE,
       base::Bind(&UpdateAndReturnProcessList, nspid_to_pid_,
                  base::Passed(&instance_processes)),
       callback);
 }
 
 scoped_refptr<base::SingleThreadTaskRunner> ArcProcessService::GetTaskRunner() {
   return heavy_task_thread_.task_runner();
 }
 
 inline ArcProcessService::NSPidToPidMap::NSPidToPidMap() {}
 
 inline ArcProcessService::NSPidToPidMap::~NSPidToPidMap() {}
 
 }  // namespace arc