Only enable the Dart timeline for benchmarks

mojo/dart/embedder/dart_controller.cc

 // Copyright 2014 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 "base/bind.h"
 #include "base/callback.h"
 #include "base/files/file_util.h"
 #include "base/logging.h"
 #include "base/path_service.h"
 #include "base/rand_util.h"
@@ skipping 334 matching lines @@
           base::MessageLoop::current()->task_runner());
       // Install message notify callback.
       Dart_SetMessageNotifyCallback(MessageNotifyCallback);
       isolate_data->set_message_notify_callback(MessageNotifyCallback);
     }
 
     // The VM is creating the service isolate.
     if (Dart_IsServiceIsolate(isolate)) {
       service_isolate_spawned_ = true;
       const intptr_t port =
-          (SupportDartMojoIo() && observatory_enabled_) ? 0 : -1;
+          (SupportDartMojoIo() && enable_observatory_) ? 0 : -1;
       InitializeDartMojoIo();
       if (!VmService::Setup("127.0.0.1", port)) {
         *error = strdup(VmService::GetErrorMessage());
         return nullptr;
       }
       return isolate;
     }
 
     tonic::DartScriptLoaderSync::LoadScript(
         script_uri,
@@ skipping 140 matching lines @@
   delete isolate_data;
 }
 
 
 bool DartController::initialized_ = false;
 MojoHandle DartController::handle_watcher_producer_handle_ =
     MOJO_HANDLE_INVALID;
 bool DartController::service_isolate_running_ = false;
 bool DartController::service_isolate_spawned_ = false;
 bool DartController::strict_compilation_ = false;
-bool DartController::observatory_enabled_ = true;
+bool DartController::enable_observatory_ = true;
 DartControllerServiceConnector* DartController::service_connector_ = nullptr;
 base::Lock DartController::lock_;
 
 bool DartController::SupportDartMojoIo() {
   return service_connector_ != nullptr;
 }
 
 void DartController::InitializeDartMojoIo() {
   Dart_Isolate current_isolate = Dart_CurrentIsolate();
   CHECK(current_isolate != nullptr);
@@ skipping 81 matching lines @@
   return array;
 }
 
 static Dart_Handle GetVMServiceAssetsArchiveCallback() {
   return MakeUint8Array(
       ::dart::observatory::observatory_assets_archive,
       ::dart::observatory::observatory_assets_archive_len);
 }
 
 void DartController::InitVmIfNeeded(Dart_EntropySource entropy,
+                                    bool enable_dart_timeline,
                                     const char** vm_flags,
                                     int vm_flags_count) {
   base::AutoLock al(lock_);
   if (initialized_) {
     return;
   }
 
   // Start a handle watcher.
   handle_watcher_producer_handle_ = HandleWatcher::Start();
 
@@ skipping 29 matching lines @@
       IsolateCreateCallback,
       nullptr,  // Deprecated isolate interrupt callback. Must pass nullptr.
       nullptr,  // Deprecated unhandled exception callback. Must pass nullptr.
       IsolateShutdownCallback,
       // File IO callbacks.
       nullptr, nullptr, nullptr, nullptr,
       entropy,
       GetVMServiceAssetsArchiveCallback);
   CHECK(error == nullptr);
   initialized_ = true;
+  if (enable_dart_timeline) {
+    Dart_GlobalTimelineSetRecordedStreams(DART_TIMELINE_STREAM_DART);
+  }
 }
 
 void DartController::BlockForServiceIsolate() {
   base::AutoLock al(lock_);
   BlockForServiceIsolateLocked();
 }
 
 void DartController::BlockForServiceIsolateLocked() {
   if (service_isolate_running_) {
     return;
   }
   // By waiting for the load port, we ensure that the service isolate is fully
   // running before returning.
   Dart_ServiceWaitForLoadPort();
   service_isolate_running_ = true;
 }
 
 static bool GenerateEntropy(uint8_t* buffer, intptr_t length) {
   base::RandBytes(reinterpret_cast<void*>(buffer), length);
   return true;
 }
 
 bool DartController::Initialize(
     DartControllerServiceConnector* service_connector,
     bool strict_compilation,
-    bool observatory_enabled,
+    bool enable_observatory,
+    bool enable_dart_timeline,
     const char** extra_args,
     int extra_args_count) {
   service_connector_ = service_connector;
-  observatory_enabled_ = observatory_enabled;
+  enable_observatory_ = enable_observatory;
   strict_compilation_ = strict_compilation;
-  InitVmIfNeeded(GenerateEntropy, extra_args, extra_args_count);
+  InitVmIfNeeded(GenerateEntropy,
+                 enable_dart_timeline,
+                 extra_args,
+                 extra_args_count);
   return true;
 }
 
 bool DartController::RunToCompletion(Dart_Isolate isolate) {
   return !RunIsolate(isolate);
 }
 
 void DartController::SetIsolateFlags(Dart_IsolateFlags* flags,
                                      bool strict_compilation) {
   flags->version = DART_FLAGS_CURRENT_VERSION;
@@ skipping 40 matching lines @@
   }
   BlockForServiceIsolateLocked();
   HandleWatcher::StopAll();
   Dart_Cleanup();
   service_isolate_running_ = false;
   initialized_ = false;
 }
 
 }  // namespace apps
 }  // namespace mojo