arc: Convert more Mojo types to STL

components/arc/metrics/arc_metrics_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.
 
 #include "components/arc/metrics/arc_metrics_service.h"
 
 #include <string>
 #include <utility>
 
 #include "base/logging.h"
@@ skipping 69 matching lines @@
       arc_bridge_service()->process()->GetInstanceForMethod(
           "RequestProcessList");
   if (!process_instance)
     return;
   VLOG(2) << "RequestProcessList";
   process_instance->RequestProcessList(base::Bind(
       &ArcMetricsService::ParseProcessList, weak_ptr_factory_.GetWeakPtr()));
 }
 
 void ArcMetricsService::ParseProcessList(
-    mojo::Array<mojom::RunningAppProcessInfoPtr> processes) {
+    std::vector<mojom::RunningAppProcessInfoPtr> processes) {
   int running_app_count = 0;
   for (const auto& process : processes) {
-    const mojo::String& process_name = process->process_name;
+    const std::string& process_name = process->process_name;
     const mojom::ProcessState& process_state = process->process_state;
 
     // Processes like the ARC launcher and intent helper are always running
     // and not counted as apps running by users. With the same reasoning,
     // GMS (Google Play Services) and its related processes are skipped as
     // well. The process_state check below filters out system processes,
     // services, apps that are cached because they've run before.
-    if (base::StartsWith(process_name.get(), kArcProcessNamePrefix,
+    if (base::StartsWith(process_name, kArcProcessNamePrefix,
                          base::CompareCase::SENSITIVE) ||
-        base::StartsWith(process_name.get(), kGmsProcessNamePrefix,
+        base::StartsWith(process_name, kGmsProcessNamePrefix,
                          base::CompareCase::SENSITIVE) ||
         process_state != mojom::ProcessState::TOP) {
       VLOG(2) << "Skipped " << process_name << " " << process_state;
     } else {
       ++running_app_count;
     }
   }
 
   UMA_HISTOGRAM_COUNTS_100("Arc.AppCount", running_app_count);
 }
@@ skipping 17 matching lines @@
   if (!binding_.is_bound()) {
     mojom::MetricsHostPtr host_ptr;
     binding_.Bind(mojo::GetProxy(&host_ptr));
     instance->Init(std::move(host_ptr));
   }
   arc_start_time_ = arc_start_time;
   VLOG(2) << "ARC start @" << arc_start_time_;
 }
 
 void ArcMetricsService::ReportBootProgress(
-    mojo::Array<mojom::BootProgressEventPtr> events) {
+    std::vector<mojom::BootProgressEventPtr> events) {
   DCHECK(CalledOnValidThread());
   int64_t arc_start_time_in_ms =
       (arc_start_time_ - base::TimeTicks()).InMilliseconds();
   for (const auto& event : events) {
     VLOG(2) << "Report boot progress event:" << event->event << "@"
             << event->uptimeMillis;
-    std::string title = "Arc." + event->event.get();
+    std::string title = "Arc." + event->event;
     base::TimeDelta elapsed_time = base::TimeDelta::FromMilliseconds(
         event->uptimeMillis - arc_start_time_in_ms);
     // Note: This leaks memory, which is expected behavior.
     base::HistogramBase* histogram = base::Histogram::FactoryTimeGet(
         title, base::TimeDelta::FromMilliseconds(1),
         base::TimeDelta::FromSeconds(30), 50,
         base::HistogramBase::kUmaTargetedHistogramFlag);
     histogram->AddTime(elapsed_time);
-    if (event->event.get().compare(kBootProgressEnableScreen) == 0)
+    if (event->event.compare(kBootProgressEnableScreen) == 0)
       UMA_HISTOGRAM_CUSTOM_TIMES("Arc.AndroidBootTime", elapsed_time,
                                  base::TimeDelta::FromMilliseconds(1),
                                  base::TimeDelta::FromSeconds(30), 50);
   }
 }
 
 ArcMetricsService::ProcessObserver::ProcessObserver(
     ArcMetricsService* arc_metrics_service)
     : arc_metrics_service_(arc_metrics_service) {}
 
 ArcMetricsService::ProcessObserver::~ProcessObserver() = default;
 
 void ArcMetricsService::ProcessObserver::OnInstanceReady() {
   arc_metrics_service_->OnProcessInstanceReady();
 }
 
 void ArcMetricsService::ProcessObserver::OnInstanceClosed() {
   arc_metrics_service_->OnProcessInstanceClosed();
 }
 
 }  // namespace arc