Teach the mojo_shell --trace-startup flag to gather data from services

shell/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 "shell/context.h"
 
 #include <vector>
 
 #include "base/base_switches.h"
 #include "base/bind.h"
@@ skipping 18 matching lines @@
 #include "mojo/public/cpp/application/application_delegate.h"
 #include "mojo/public/cpp/application/application_impl.h"
 #include "services/tracing/tracing.mojom.h"
 #include "shell/application_manager/application_loader.h"
 #include "shell/application_manager/application_manager.h"
 #include "shell/command_line_util.h"
 #include "shell/filename_util.h"
 #include "shell/in_process_native_runner.h"
 #include "shell/out_of_process_native_runner.h"
 #include "shell/switches.h"
+#include "shell/tracer.h"
 #include "url/gurl.h"
 
 using mojo::ServiceProvider;
 using mojo::ServiceProviderPtr;
 
 namespace shell {
 namespace {
 
 // Used to ensure we only init once.
 class Setup {
@@ skipping 120 matching lines @@
     }
 
     NativeRunnerFactory::Options options;
     options.force_in_process = true;
     manager->SetNativeOptionsForURL(options, gurl);
   }
 }
 
 class TracingServiceProvider : public ServiceProvider {
  public:
-  explicit TracingServiceProvider(
-      mojo::InterfaceRequest<ServiceProvider> request)
-      : binding_(this, request.Pass()) {}
+  TracingServiceProvider(Tracer* tracer,
+                         mojo::InterfaceRequest<ServiceProvider> request)
+      : tracer_(tracer), binding_(this, request.Pass()) {}
   ~TracingServiceProvider() override {}
 
   void ConnectToService(const mojo::String& service_name,
                         mojo::ScopedMessagePipeHandle client_handle) override {
-    if (service_name == tracing::TraceController::Name_) {
-      new mojo::TraceControllerImpl(
+    if (tracer_ && service_name == tracing::TraceController::Name_) {
+      tracer_->ConnectToController(
           mojo::MakeRequest<tracing::TraceController>(client_handle.Pass()));
     }
   }
 
  private:
+  Tracer* tracer_;
   mojo::StrongBinding<mojo::ServiceProvider> binding_;
 
   DISALLOW_COPY_AND_ASSIGN(TracingServiceProvider);
 };
 
 }  // namespace
 
-Context::Context() : application_manager_(this) {
+Context::Context(Tracer* tracer) : tracer_(tracer), application_manager_(this) {
   DCHECK(!base::MessageLoop::current());
 
   // By default assume that the local apps reside alongside the shell.
   // TODO(ncbray): really, this should be passed in rather than defaulting.
   // This default makes sense for desktop but not Android.
   base::FilePath shell_dir;
   PathService::Get(base::DIR_MODULE, &shell_dir);
   SetShellFileRoot(shell_dir);
 
   base::FilePath cwd;
@@ skipping 68 matching lines @@
     runner_factory.reset(new InProcessNativeRunnerFactory(this));
   application_manager_.set_blocking_pool(task_runners_->blocking_pool());
   application_manager_.set_native_runner_factory(runner_factory.Pass());
   application_manager_.set_disable_cache(
       base::CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kDisableCache));
 
   InitContentHandlers(&application_manager_, command_line);
   InitNativeOptions(&application_manager_, command_line);
 
-  ServiceProviderPtr tracing_service_provider_ptr;
-  new TracingServiceProvider(mojo::GetProxy(&tracing_service_provider_ptr));
+  ServiceProviderPtr tracing_services;
+  ServiceProviderPtr tracing_exposed_services;
+  new TracingServiceProvider(tracer_, GetProxy(&tracing_exposed_services));
   application_manager_.ConnectToApplication(
-      GURL("mojo:tracing"), GURL(""), nullptr,
-      tracing_service_provider_ptr.Pass(), base::Closure());
+      GURL("mojo:tracing"), GURL(""), GetProxy(&tracing_services),
+      tracing_exposed_services.Pass(), base::Closure());
+
+  if (command_line.HasSwitch(switches::kTraceStartup)) {
+    DCHECK(tracer_);
+    tracing::TraceCoordinatorPtr coordinator;
+    auto coordinator_request = GetProxy(&coordinator);
+    tracing_services->ConnectToService(tracing::TraceCoordinator::Name_,
+                                       coordinator_request.PassMessagePipe());
+    tracer_->StartCollectingFromTracingService(coordinator.Pass());
+  }
 
   return true;
 }
 
 void Context::Shutdown() {
   TRACE_EVENT0("mojo_shell", "Context::Shutdown");
   DCHECK_EQ(base::MessageLoop::current()->task_runner(),
             task_runners_->shell_runner());
   mojo::embedder::ShutdownIPCSupport();
   // We'll quit when we get OnShutdownComplete().
@@ skipping 29 matching lines @@
     app_urls_.erase(url);
     if (app_urls_.empty() && base::MessageLoop::current()->is_running()) {
       DCHECK_EQ(base::MessageLoop::current()->task_runner(),
                 task_runners_->shell_runner());
       base::MessageLoop::current()->Quit();
     }
   }
 }
 
 }  // namespace shell