Mark ApplicationImpl::ConnectTo{Application,Service}() as deprecated.

apps/benchmark/benchmark_app.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 <memory>
 #include <set>
 #include <string>
 #include <vector>
 
 #include "apps/benchmark/event.h"
@@ skipping 37 matching lines @@
     std::string categories_str;
     if (args_.write_output_file) {
       categories_str = "*";
     } else {
       categories_str = ComputeCategoriesStr();
     }
 
     // Connect to trace collector, which will fetch the trace events produced by
     // the app being benchmarked.
     tracing::TraceCollectorPtr trace_collector;
-    app->ConnectToService("mojo:tracing", &trace_collector);
+    app->ConnectToServiceDeprecated("mojo:tracing", &trace_collector);
     trace_collector_client_.reset(
         new TraceCollectorClient(this, trace_collector.Pass()));
     trace_collector_client_->Start(categories_str);
 
     // Start tracing the application with 1 sec of delay.
     base::MessageLoop::current()->PostDelayedTask(
         FROM_HERE, base::Bind(&BenchmarkApp::StartTracedApplication,
                               base::Unretained(this), app),
         base::TimeDelta::FromSeconds(1));
   }
 
   // Computes the string of trace categories we want to collect: a union of all
   // categories targeted in measurements.
   std::string ComputeCategoriesStr() {
     std::set<std::string> category_set;
     for (const Measurement& measurement : args_.measurements) {
       std::vector<std::string> categories;
       base::SplitString(measurement.target_event.categories, ',', &categories);
       category_set.insert(categories.begin(), categories.end());
     }
     std::vector<std::string> unique_categories(category_set.begin(),
                                                category_set.end());
     return base::JoinString(unique_categories, ",");
   }
 
   void StartTracedApplication(mojo::ApplicationImpl* app) {
     // Record the time origin for measurements just before connecting to the app
     // being benchmarked.
     time_origin_ = base::TimeTicks::FromInternalValue(MojoGetTimeTicksNow());
-    traced_app_connection_ = app->ConnectToApplication(args_.app);
+    traced_app_connection_ = app->ConnectToApplicationDeprecated(args_.app);
 
     // Post task to stop tracing when the time is up.
     base::MessageLoop::current()->PostDelayedTask(
         FROM_HERE,
         base::Bind(&BenchmarkApp::StopTracing, base::Unretained(this)),
         args_.duration);
   }
 
   void StopTracing() {
     // Request the trace collector to send back the data. When the data is ready
@@ skipping 56 matching lines @@
 };
 }  // namespace
 }  // namespace benchmark
 
 MojoResult MojoMain(MojoHandle application_request) {
   mojo::ApplicationRunnerChromium runner(new benchmark::BenchmarkApp);
   auto ret = runner.Run(application_request);
   fflush(nullptr);
   return ret;
 }