Add module suffix in .mojom files for components/arc

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"
@@ skipping 63 matching lines @@
 
 void ArcProcessService::Reset() {
   DCHECK(thread_checker_.CalledOnValidThread());
   nspid_to_pid_.clear();
 }
 
 bool ArcProcessService::RequestProcessList(
     RequestProcessListCallback callback) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
 
-  arc::ProcessInstance* process_instance =
+  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;
 }
 
 void ArcProcessService::OnReceiveProcessList(
-      const RequestProcessListCallback& callback,
-      mojo::Array<arc::RunningAppProcessInfoPtr> mojo_processes) {
+    const RequestProcessListCallback& callback,
+    mojo::Array<arc::mojom::RunningAppProcessInfoPtr> mojo_processes) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
 
-  auto raw_processes = new vector<RunningAppProcessInfoPtr>();
+  auto raw_processes = new vector<mojom::RunningAppProcessInfoPtr>();
   mojo_processes.Swap(raw_processes);
 
   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
@@ skipping 14 matching lines @@
 }
 
 void ArcProcessService::CallbackRelay(
     const RequestProcessListCallback& callback,
     const vector<ArcProcess>* ret_processes) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
   callback.Run(*ret_processes);
 }
 
 void ArcProcessService::UpdateAndReturnProcessList(
-    const vector<arc::RunningAppProcessInfoPtr>* raw_processes,
+    const vector<arc::mojom::RunningAppProcessInfoPtr>* raw_processes,
     vector<ArcProcess>* ret_processes) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   // Cleanup dead pids in the cache |nspid_to_pid_|.
   set<ProcessId> nspid_to_remove;
   for (const auto& entry : nspid_to_pid_) {
     nspid_to_remove.insert(entry.first);
   }
   bool unmapped_nspid = false;
   for (const auto& entry : *raw_processes) {
     // erase() returns 0 if coudln't find the key. It means a new process.
     if (nspid_to_remove.erase(entry->pid) == 0) {
       nspid_to_pid_[entry->pid] = kNullProcessId;
       unmapped_nspid = true;
     }
   }
   for (const auto& entry : nspid_to_remove) {
     nspid_to_pid_.erase(entry);
   }
 
   // The operation is costly so avoid calling it when possible.
   if (unmapped_nspid) {
     UpdateNspidToPidMap();
   }
 
   PopulateProcessList(raw_processes, ret_processes);
 }
 
 void ArcProcessService::PopulateProcessList(
-    const vector<arc::RunningAppProcessInfoPtr>* raw_processes,
+    const vector<arc::mojom::RunningAppProcessInfoPtr>* raw_processes,
     vector<ArcProcess>* ret_processes) {
   DCHECK(thread_checker_.CalledOnValidThread());
   for (const auto& entry : *raw_processes) {
     const auto it = nspid_to_pid_.find(entry->pid);
     // In case the process already dies so couldn't find corresponding pid.
     if (it != nspid_to_pid_.end() && it->second != kNullProcessId) {
       ArcProcess arc_process = {
           entry->pid, it->second, entry->process_name, entry->process_state};
       ret_processes->push_back(arc_process);
     }
@@ skipping 58 matching lines @@
           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);
     }
   }
 }
 
 }  // namespace arc