Compress sources of JS libraries in addition to the snapshot.

samples/shell.cc

 // Copyright 2011 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 27 matching lines @@
 
 // When building with V8 in a shared library we cannot use functions which
 // is not explicitly a part of the public V8 API. This extensive use of
 // #ifndef USING_V8_SHARED/#endif is a hack until we can resolve whether to
 // still use the shell sample for testing or change to use the developer
 // shell d8 TODO(1272).
 #if !(defined(USING_V8_SHARED) || defined(V8_SHARED))
 #include "../src/v8.h"
 #endif  // USING_V8_SHARED
 
+// Natives decompressor is a part of V8 sources because it is used in
+// mksnapshot.
+#ifdef COMPRESS_STARTUP_DATA_BZ2
+#include "../src/bz2-decompress.h"
+#endif
+
 #if !defined(_WIN32) && !defined(_WIN64)
 #include <unistd.h>  // NOLINT
 #endif
 
 static void ExitShell(int exit_code) {
   // Use _exit instead of exit to avoid races between isolate
   // threads and static destructors.
   fflush(stdout);
   fflush(stderr);
   _exit(exit_code);
@@ skipping 238 matching lines @@
       argv[i] = NULL;
     } else if (strcmp(argv[i], "--noalways-opt") == 0) {
       // No support for stressing if we can't use --always-opt.
       FLAG_stress_opt = false;
       FLAG_stress_deopt = false;
       break;
     }
   }
 
 #ifdef COMPRESS_STARTUP_DATA_BZ2
-  ASSERT_EQ(v8::StartupData::kBZip2,
-            v8::V8::GetCompressedStartupDataAlgorithm());
-  int compressed_data_count = v8::V8::GetCompressedStartupDataCount();
-  v8::StartupData* compressed_data = new v8::StartupData[compressed_data_count];
-  v8::V8::GetCompressedStartupData(compressed_data);
-  for (int i = 0; i < compressed_data_count; ++i) {
-    char* decompressed = new char[compressed_data[i].raw_size];
-    unsigned int decompressed_size = compressed_data[i].raw_size;
-    int result =
-        BZ2_bzBuffToBuffDecompress(decompressed,
-                                   &decompressed_size,
-                                   const_cast<char*>(compressed_data[i].data),
-                                   compressed_data[i].compressed_size,
-                                   0, 1);
-    if (result != BZ_OK) {
-      fprintf(stderr, "bzip error code: %d\n", result);
-      exit(1);
-    }
-    compressed_data[i].data = decompressed;
-    compressed_data[i].raw_size = decompressed_size;
+  BZip2Decompressor startup_data_decompressor;

[Vitaly Repeshko, 2011/06/06 15:59:15]

It seems unfortunate that the shell sample is using something that looks like
internal code to demonstrate the compression feature. Could you document that
it's safe to use its implementation details? Or how about we expose a documented
convenience API DecompressWithCallback?

+  int bz2_result = startup_data_decompressor.DecompressStartupData();
+  if (bz2_result != BZ_OK) {
+    fprintf(stderr, "bzip error code: %d\n", bz2_result);
+    exit(1);
   }
-  v8::V8::SetDecompressedStartupData(compressed_data);
-#endif  // COMPRESS_STARTUP_DATA_BZ2
+#endif
 
   v8::V8::SetFlagsFromCommandLine(&argc, argv, true);
   int result = 0;
   if (FLAG_stress_opt || FLAG_stress_deopt) {
     v8::Testing::SetStressRunType(FLAG_stress_opt
                                   ? v8::Testing::kStressTypeOpt
                                   : v8::Testing::kStressTypeDeopt);
     int stress_runs = v8::Testing::GetStressRuns();
     for (int i = 0; i < stress_runs && result == 0; i++) {
       printf("============ Stress %d/%d ============\n",
              i + 1, stress_runs);
       v8::Testing::PrepareStressRun(i);
       last_run = (i == stress_runs - 1);
       result = RunMain(argc, argv);
     }
     printf("======== Full Deoptimization =======\n");
     v8::Testing::DeoptimizeAll();
   } else {
     result = RunMain(argc, argv);
   }
   v8::V8::Dispose();
 
-#ifdef COMPRESS_STARTUP_DATA_BZ2
-  for (int i = 0; i < compressed_data_count; ++i) {
-    delete[] compressed_data[i].data;
-  }
-  delete[] compressed_data;
-#endif  // COMPRESS_STARTUP_DATA_BZ2
-
   return result;
 }
 
 
 // Extracts a C string from a V8 Utf8Value.
 const char* ToCString(const v8::String::Utf8Value& value) {
   return *value ? *value : "<string conversion failed>";
 }
 
 
@@ skipping 303 matching lines @@
       printf("^");
     }
     printf("\n");
     v8::String::Utf8Value stack_trace(try_catch->StackTrace());
     if (stack_trace.length() > 0) {
       const char* stack_trace_string = ToCString(stack_trace);
       printf("%s\n", stack_trace_string);
     }
   }
 }