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
+#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;
+base::MemoryMappedFile IsolateHolder::mapped_snapshot;

[rmcilroy, 2014/09/23 10:04:20]

We only allow POD types (not class objects) as static variables in Chrome code
(there is a limit on static initializers which means we avoid static object's). 
You could make these both pointers (which would avoid the need for the bool
since you could just check whether the points are NULL or not.

Also, please move these into the anonymous namespace above.

[baixo, 2014/09/23 11:36:46]

Done.
This is not possible because the anonymous namespace does not enclose the
IsolateHolder namespace.

+bool IsolateHolder::read_snapshot = false;
+#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 (read_snapshot)
+    return true;
+
+  if (!mapped_natives.IsValid()) {
+    if (!mapped_natives.Initialize(base::File(natives_fd))) {
+      LOG(ERROR) << "Couldn't mmap v8 natives data file";
+      return false;
+    }
+  }
+
+  if (!mapped_snapshot.IsValid()) {
+    if (!mapped_snapshot.Initialize(base::File(snapshot_fd))) {
+      LOG(ERROR) << "Couldn't mmap v8 snapshot data file";
+      return false;
+    }
+  }
+
+  read_snapshot = true;
+  return true;
+}
+#endif  // V8_USE_EXTERNAL_STARTUP_DATA && OS_ANDROID
+
+#ifdef V8_USE_EXTERNAL_STARTUP_DATA
+// static
+bool IsolateHolder::LoadV8Snapshot() {
+  if (read_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());
+
+  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;
+    }
+  }
+  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;
+    }
+  }
+
+  read_snapshot = true;
+  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