Make Tracing Service not use outgoing InterfaceProvider, update conventions

services/shell/standalone/context.cc

 // Copyright 2013 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 "services/shell/standalone/context.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <utility>
@@ skipping 21 matching lines @@
 #include "mojo/edk/embedder/embedder.h"
 #include "mojo/public/cpp/bindings/strong_binding.h"
 #include "services/catalog/catalog.h"
 #include "services/catalog/store.h"
 #include "services/shell/connect_params.h"
 #include "services/shell/public/cpp/names.h"
 #include "services/shell/runner/host/in_process_native_runner.h"
 #include "services/shell/runner/host/out_of_process_native_runner.h"
 #include "services/shell/standalone/tracer.h"
 #include "services/shell/switches.h"
+#include "services/tracing/public/cpp/provider.h"
 #include "services/tracing/public/cpp/switches.h"
-#include "services/tracing/public/cpp/trace_provider_impl.h"
-#include "services/tracing/public/cpp/tracing_impl.h"
 #include "services/tracing/public/interfaces/tracing.mojom.h"
 
 #if defined(OS_MACOSX)
 #include "services/shell/runner/host/mach_broker.h"
 #endif
 
 namespace shell {
 namespace {
 
 // Used to ensure we only init once.
@@ skipping 10 matching lines @@
 class TracingInterfaceProvider : public mojom::InterfaceProvider {
  public:
   TracingInterfaceProvider(Tracer* tracer,
                            mojom::InterfaceProviderRequest request)
       : tracer_(tracer), binding_(this, std::move(request)) {}
   ~TracingInterfaceProvider() override {}
 
   // mojom::InterfaceProvider:
   void GetInterface(const mojo::String& interface_name,
                     mojo::ScopedMessagePipeHandle client_handle) override {
-    if (tracer_ && interface_name == tracing::TraceProvider::Name_) {
+    if (tracer_ && interface_name == tracing::mojom::Provider::Name_) {
       tracer_->ConnectToProvider(
-          mojo::MakeRequest<tracing::TraceProvider>(std::move(client_handle)));
+          mojo::MakeRequest<tracing::mojom::Provider>(
+              std::move(client_handle)));
     }
   }
 
  private:
   Tracer* tracer_;
   mojo::StrongBinding<mojom::InterfaceProvider> binding_;
 
   DISALLOW_COPY_AND_ASSIGN(TracingInterfaceProvider);
 };
 
@@ skipping 89 matching lines @@
   new TracingInterfaceProvider(&tracer_, GetProxy(&tracing_local_interfaces));
 
   std::unique_ptr<ConnectParams> params(new ConnectParams);
   params->set_source(CreateServiceManagerIdentity());
   params->set_target(Identity("mojo:tracing", mojom::kRootUserID));
   params->set_remote_interfaces(mojo::GetProxy(&tracing_remote_interfaces));
   params->set_local_interfaces(std::move(tracing_local_interfaces));
   service_manager_->Connect(std::move(params));
 
   if (command_line.HasSwitch(tracing::kTraceStartup)) {
-    tracing::TraceCollectorPtr coordinator;
+    tracing::mojom::CollectorPtr coordinator;
     auto coordinator_request = GetProxy(&coordinator);
     tracing_remote_interfaces->GetInterface(
-        tracing::TraceCollector::Name_, coordinator_request.PassMessagePipe());
+        tracing::mojom::Collector::Name_,
+        coordinator_request.PassMessagePipe());
     tracer_.StartCollectingFromTracingService(std::move(coordinator));
   }
 
   // Record the shell startup metrics used for performance testing.
   if (base::CommandLine::ForCurrentProcess()->HasSwitch(
           tracing::kEnableStatsCollectionBindings)) {
-    tracing::StartupPerformanceDataCollectorPtr collector;
+    tracing::mojom::StartupPerformanceDataCollectorPtr collector;
     tracing_remote_interfaces->GetInterface(
-        tracing::StartupPerformanceDataCollector::Name_,
+        tracing::mojom::StartupPerformanceDataCollector::Name_,
         mojo::GetProxy(&collector).PassMessagePipe());
 #if defined(OS_MACOSX) || defined(OS_WIN) || defined(OS_LINUX)
     // CurrentProcessInfo::CreationTime is only defined on some platforms.
     const base::Time creation_time = base::CurrentProcessInfo::CreationTime();
     collector->SetShellProcessCreationTime(creation_time.ToInternalValue());
 #endif
     collector->SetShellMainEntryPointTime(main_entry_time_.ToInternalValue());
   }
 }
 
@@ skipping 46 matching lines @@
 
   std::unique_ptr<ConnectParams> params(new ConnectParams);
   params->set_source(CreateServiceManagerIdentity());
   params->set_target(Identity(name, mojom::kRootUserID));
   params->set_remote_interfaces(mojo::GetProxy(&remote_interfaces));
   params->set_local_interfaces(std::move(local_interfaces));
   service_manager_->Connect(std::move(params));
 }
 
 }  // namespace shell