Infrastructure for reading V8's initial snapshot from external files

gin/isolate_holder.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 "gin/public/isolate_holder.h"
 
 #include <stdlib.h>
 #include <string.h>
 
 #include "base/logging.h"
+#ifdef V8_USE_EXTERNAL_STARTUP_DATA
+
+#ifdef OS_MACOSX
+#include "base/mac/bundle_locations.h"
+#endif
+

[rmcilroy, 2014/09/23 14:05:40]

nit - Generally Ifdef'ed defines are placed in a separate section below the
unconditional includes.  Could you do that here and in the other files please.

[baixo, 2014/09/23 19:30:30]

Done.

+#include "base/path_service.h"
+#endif  // V8_USE_EXTERNAL_STARTUP_DATA
 #include "base/rand_util.h"
 #include "base/sys_info.h"
 #include "gin/array_buffer.h"
 #include "gin/debug_impl.h"
 #include "gin/function_template.h"
 #include "gin/per_isolate_data.h"
 #include "gin/public/v8_platform.h"
 
 namespace gin {
 
 namespace {
 
 v8::ArrayBuffer::Allocator* g_array_buffer_allocator = NULL;
 
 bool GenerateEntropy(unsigned char* buffer, size_t amount) {
   base::RandBytes(buffer, amount);
   return true;
 }
 
 }  // namespace
 
+#ifdef V8_USE_EXTERNAL_STARTUP_DATA
+// static
+base::MemoryMappedFile* IsolateHolder::mapped_natives = NULL;
+base::MemoryMappedFile* IsolateHolder::mapped_snapshot = NULL;

[rmcilroy, 2014/09/23 14:05:40]

As mentioned, these should be globals, not static members (as with
g_array_buffer_allocator above).  Please also rename to prefix with "g_" and
move to the above anonymous namespace (which is possible when they are globals
not static members.

[baixo, 2014/09/23 19:30:30]

Done.

+#endif  // V8_USE_EXTERNAL_STARTUP_DATA
+
+#if defined(V8_USE_EXTERNAL_STARTUP_DATA) && defined(OS_ANDROID)
+//static
+bool IsolateHolder::LoadV8SnapshotFD(int natives_fd, int snapshot_fd) {
+  if (mapped_natives && mapped_snapshot)
+    return true;
+
+  mapped_natives = new base::MemoryMappedFile;
+  CHECK(mapped_natives);
+  if (!mapped_natives->IsValid()) {
+    if (!mapped_natives->Initialize(base::File(natives_fd))) {

[rmcilroy, 2014/09/23 14:05:39]

create the new mapped_snapshot here rather than above such that it remains null
if the load fails.

[baixo, 2014/09/23 19:30:30]

We need the created object to initialize the file in first place. So now, if we
are unable to initialize the file, I'm deleting the object and setting the
pointer back to NULL.

+      LOG(ERROR) << "Couldn't mmap v8 natives data file";
+      return false;
+    }
+  }
+
+  mapped_snapshot = new base::MemoryMappedFile;

[rmcilroy, 2014/09/23 14:05:39]

ditto

[baixo, 2014/09/23 19:30:30]

Same as above.

+  CHECK(mapped_snapshot);
+  if (!mapped_snapshot->IsValid()) {
+    if (!mapped_snapshot->Initialize(base::File(snapshot_fd))) {
+      LOG(ERROR) << "Couldn't mmap v8 snapshot data file";
+      return false;
+    }
+  }
+
+  return true;
+}
+#endif  // V8_USE_EXTERNAL_STARTUP_DATA && OS_ANDROID
+
+#ifdef V8_USE_EXTERNAL_STARTUP_DATA
+// static
+bool IsolateHolder::LoadV8Snapshot() {
+  if (mapped_natives && mapped_snapshot)
+    return true;
+
+#if !defined(OS_MACOSX)
+  base::FilePath data_path;
+  PathService::Get(
+#if defined(OS_ANDROID)
+    base::DIR_ANDROID_APP_DATA,
+#elif defined(OS_POSIX) || defined(OS_WIN)
+    base::DIR_EXE,
+#endif
+    &data_path);
+#else
+  base::FilePath data_path = base::mac::FrameworkBundlePath();
+#endif
+  DCHECK(!data_path.empty());
+
+  mapped_natives = new base::MemoryMappedFile;
+  CHECK(mapped_natives);
+  if (!mapped_natives->IsValid()) {
+    base::FilePath natives_data_path =
+      data_path.AppendASCII("natives_blob.bin");
+    if (!mapped_natives->Initialize(natives_data_path)) {
+      LOG(ERROR) << "Couldn't mmap v8 natives data file";
+      return false;
+    }
+  }

[rmcilroy, 2014/09/23 14:05:39]

There seems like a lot of duplication here between LoadV8Snapshot and
LoadV8SnapshotFD.  Could you split some code out into shared functions?

[baixo, 2014/09/23 19:30:30]

Done.

+
+  mapped_snapshot = new base::MemoryMappedFile;
+  CHECK(mapped_snapshot);
+  if (!mapped_snapshot->IsValid()) {
+    base::FilePath snapshot_data_path =
+      data_path.AppendASCII("snapshot_blob.bin");
+    if (!mapped_snapshot->Initialize(snapshot_data_path)) {
+      LOG(ERROR) << "Couldn't mmap v8 snapshot data file";
+      return false;
+    }
+  }
+
+  return true;
+}
+#endif  // V8_USE_EXTERNAL_STARTUP_DATA
+
 IsolateHolder::IsolateHolder() {
   CHECK(g_array_buffer_allocator)
       << "You need to invoke gin::IsolateHolder::Initialize first";
   v8::Isolate::CreateParams params;
   params.entry_hook = DebugImpl::GetFunctionEntryHook();
   params.code_event_handler = DebugImpl::GetJitCodeEventHandler();
   params.constraints.ConfigureDefaults(base::SysInfo::AmountOfPhysicalMemory(),
                                        base::SysInfo::AmountOfVirtualMemory(),
                                        base::SysInfo::NumberOfProcessors());
   isolate_ = v8::Isolate::New(params);
@@ skipping 13 matching lines @@
   if (v8_is_initialized)
     return;
   v8::V8::InitializePlatform(V8Platform::Get());
   v8::V8::SetArrayBufferAllocator(allocator);
   g_array_buffer_allocator = allocator;
   if (mode == gin::IsolateHolder::kStrictMode) {
     static const char v8_flags[] = "--use_strict";
     v8::V8::SetFlagsFromString(v8_flags, sizeof(v8_flags) - 1);
   }
   v8::V8::SetEntropySource(&GenerateEntropy);
+#ifdef V8_USE_EXTERNAL_STARTUP_DATA
+  v8::StartupData natives;
+  natives.data = reinterpret_cast<const char*>(mapped_natives->data());
+  natives.raw_size = mapped_natives->length();
+  natives.compressed_size = mapped_natives->length();
+  v8::V8::SetNativesDataBlob(&natives);
+
+  v8::StartupData snapshot;
+  snapshot.data = reinterpret_cast<const char*>(mapped_snapshot->data());
+  snapshot.raw_size = mapped_snapshot->length();
+  snapshot.compressed_size = mapped_snapshot->length();
+  v8::V8::SetSnapshotDataBlob(&snapshot);
+#endif  // V8_USE_EXTERNAL_STARTUP_DATA
   v8::V8::Initialize();
   v8_is_initialized = true;
 }
 
 }  // namespace gin