- Remove loading of observatory assets from dart_bootstrap.

runtime/bin/main.cc

 // Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 #include <stdlib.h>
 #include <string.h>
 #include <stdio.h>
 
 #include "include/dart_api.h"
 #include "include/dart_tools_api.h"
@@ skipping 27 matching lines @@
 // isolate_snapshot_buffer points to a snapshot for an isolate if we link in a
 // snapshot otherwise it is initialized to NULL.
 extern const uint8_t* isolate_snapshot_buffer;
 
 /**
  * Global state used to control and store generation of application snapshots
  * (script/full).
  * A full application snapshot can be generated and run using the following
  * commands
  * - Generating a full application snapshot :
- * dart_no_snapshot --full-snapshot-after-run=<filename> --package-root=<dirs>
+ * dart_bootstrap --full-snapshot-after-run=<filename> --package-root=<dirs>
  *   <script_uri> [<script_options>]
  * - Running the full application snapshot generated above :
  * dart --run-full-snapshot=<filename> <script_uri> [<script_options>]
  */
 static bool generate_script_snapshot = false;
 static bool generate_full_snapshot_after_run = false;
 static bool run_full_snapshot = false;
 static const char* snapshot_filename = NULL;
 
 // Value of the --package-root flag.
@@ skipping 261 matching lines @@
     return false;
   }
   compile_all = true;
   return true;
 }
 
 
 static bool ProcessGenPrecompiledSnapshotOption(
     const char* arg,
     CommandLineOptions* vm_options) {
-  // Ensure that we are not already running using a full snapshot.
-  if (isolate_snapshot_buffer != NULL) {
-    Log::PrintErr("Precompiled snapshots must be generated with"
-                  " dart_no_snapshot.\n");
-    return false;
-  }
+#if !defined(DART_PRECOMPILER)
+  Log::PrintErr("Precompiled snapshots must be generated with "
+                "dart_bootstrap.\n");
+  return false;
+#else  // defined(DART_PRECOMPILER)
   ASSERT(arg != NULL);
   if ((arg[0] == '=') || (arg[0] == ':')) {
     precompiled_snapshot_directory = &arg[1];
   } else {
     precompiled_snapshot_directory = arg;
   }
   gen_precompiled_snapshot = true;
   vm_options->AddArgument("--precompilation");
   return true;
+#endif  // defined(DART_PRECOMPILER)
 }
 
 
 static bool ProcessRunPrecompiledSnapshotOption(
     const char* arg,
     CommandLineOptions* vm_options) {
   ASSERT(arg != NULL);
   precompiled_snapshot_directory = arg;
   if ((precompiled_snapshot_directory[0] == '=') ||
       (precompiled_snapshot_directory[0] == ':')) {
@@ skipping 33 matching lines @@
   }
   return ProcessSnapshotOptionHelper(filename, &generate_script_snapshot);
 }
 
 
 static bool ProcessFullSnapshotAfterRunOption(
     const char* filename, CommandLineOptions* vm_options) {
   if ((filename == NULL) || (strlen(filename) == 0)) {
     return false;
   }
-  // Ensure that we are running 'dart_no_snapshot'.
+  // Ensure that we are running 'dart_bootstrap'.
   if (isolate_snapshot_buffer != NULL) {
     Log::PrintErr("Full Application snapshots must be generated with"
-                  " dart_no_snapshot\n");
+                  " dart_bootstrap\n");
     return false;
   }
   return ProcessSnapshotOptionHelper(filename,
                                      &generate_full_snapshot_after_run);
 }
 
 
 static bool ProcessRunFullSnapshotOption(
     const char* filename, CommandLineOptions* vm_options) {
 #ifndef DART_PRODUCT_BINARY
@@ skipping 1002 matching lines @@
   Dart_ExitScope();
   // Shutdown the isolate.
   Dart_ShutdownIsolate();
 
   // No restart.
   return false;
 }
 
 #undef CHECK_RESULT
 
+
+// Observatory assets are only needed in the regular dart binary.
+#if !defined(DART_PRECOMPILER)
 extern unsigned int observatory_assets_archive_len;
 extern const uint8_t* observatory_assets_archive;
 
 
 // |input| is assumed to be a gzipped stream.
 // This function allocates the output buffer in the C heap and the caller
 // is responsible for freeing it.
 void Decompress(const uint8_t* input, unsigned int input_len,
                 uint8_t** output, unsigned int* output_length) {
   ASSERT(input != NULL);
@@ skipping 61 matching lines @@
   Decompress(observatory_assets_archive,
              observatory_assets_archive_len,
              &decompressed,
              &decompressed_len);
   Dart_Handle tar_file = DartUtils::MakeUint8Array(decompressed,
                                                    decompressed_len);
   // Free decompressed memory as it has been copied into a Dart array.
   free(decompressed);
   return tar_file;
 }
+#else  // !defined(DART_PRECOMPILER)
+static Dart_GetVMServiceAssetsArchive GetVMServiceAssetsArchiveCallback = NULL;
+#endif  // !defined(DART_PRECOMPILER)
 
 
 void main(int argc, char** argv) {
   char* script_name;
   const int EXTRA_VM_ARGUMENTS = 2;
   CommandLineOptions vm_options(argc + EXTRA_VM_ARGUMENTS);
   CommandLineOptions dart_options(argc);
   bool print_flags_seen = false;
   bool verbose_debug_seen = false;
 
@@ skipping 154 matching lines @@
   Platform::Exit(Process::GlobalExitCode());
 }
 
 }  // namespace bin
 }  // namespace dart
 
 int main(int argc, char** argv) {
   dart::bin::main(argc, argv);
   UNREACHABLE();
 }