Pass both 32 and 64 bit snapshot and natives fds to child processes.

content/browser/child_process_launcher.cc

 // Copyright 2012 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 "content/browser/child_process_launcher.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/command_line.h"
@@ skipping 138 matching lines @@
 
 #if defined(OS_POSIX) && !defined(OS_MACOSX)
   std::map<int, base::MemoryMappedFile::Region> regions;
   GetContentClient()->browser()->GetAdditionalMappedFilesForChildProcess(
       *cmd_line, child_process_id, files_to_register.get()
 #if defined(OS_ANDROID)
       , &regions
 #endif
       );
 #if defined(V8_USE_EXTERNAL_STARTUP_DATA)
+  bool snapshot_loaded = false;
+#if defined(OS_ANDROID)
+  base::MemoryMappedFile::Region region;
+  auto maybe_register = [&region, &regions, &files_to_register](int key,
+                                                                int fd) {
+    if (fd != -1) {
+      files_to_register->Share(key, fd);
+      regions.insert(std::make_pair(key, region));
+    }
+  };
+  maybe_register(
+      kV8NativesDataDescriptor32,
+      gin::V8Initializer::GetOpenNativesFileForChildProcesses(&region, true));
+  maybe_register(
+      kV8NativesDataDescriptor64,
+      gin::V8Initializer::GetOpenNativesFileForChildProcesses(&region, false));
+  maybe_register(
+      kV8SnapshotDataDescriptor32,
+      gin::V8Initializer::GetOpenSnapshotFileForChildProcesses(&region, true));
+  maybe_register(
+      kV8SnapshotDataDescriptor64,
+      gin::V8Initializer::GetOpenSnapshotFileForChildProcesses(&region, false));
+
+  snapshot_loaded = true;

[Torne, 2016/02/03 11:05:32]

Setting this to true unconditionally seems maybe wrong?

[Tobias Sargeant, 2016/02/03 11:14:11]

It's irritating, but I'm not sure what set of FDs we can reasonably test,
because we could be:

* a 32 bit monochrome with no 64 bit snapshots
  [64 bit fails]
* a 64 bit only monochrome
  [32 bit fails]
* a 64/32 bit monochrome, with either a 32 or 64 bit broser process
  [both load]

I can't see how we can't tell which bitness we need to succeed in order to start
a child (and in fact if we knew that, we wouldn't need to pass both sets). For
that reason, I think the only thing to do is to assume that everything is OK,
and let the child process complain if it isn't.

+#else
   base::PlatformFile natives_pf =
       gin::V8Initializer::GetOpenNativesFileForChildProcesses(
           &regions[kV8NativesDataDescriptor]);
   DCHECK_GE(natives_pf, 0);
   files_to_register->Share(kV8NativesDataDescriptor, natives_pf);
 
   base::MemoryMappedFile::Region snapshot_region;
   base::PlatformFile snapshot_pf =
       gin::V8Initializer::GetOpenSnapshotFileForChildProcesses(
           &snapshot_region);
   // Failure to load the V8 snapshot is not necessarily an error. V8 can start
   // up (slower) without the snapshot.
   if (snapshot_pf != -1) {
+    snapshot_loaded = true;
     files_to_register->Share(kV8SnapshotDataDescriptor, snapshot_pf);
     regions.insert(std::make_pair(kV8SnapshotDataDescriptor, snapshot_region));
   }
+#endif
 
   if (process_type != switches::kZygoteProcess) {
     cmd_line->AppendSwitch(::switches::kV8NativesPassedByFD);
-    if (snapshot_pf != -1) {
+    if (snapshot_loaded) {
       cmd_line->AppendSwitch(::switches::kV8SnapshotPassedByFD);
     }
   }
 #endif  // defined(V8_USE_EXTERNAL_STARTUP_DATA)
 #endif  // defined(OS_POSIX) && !defined(OS_MACOSX)
 
 #if defined(OS_ANDROID)
   files_to_register->Share(
       kAndroidICUDataDescriptor,
       base::i18n::GetIcuDataFileHandle(&regions[kAndroidICUDataDescriptor]));
@@ skipping 338 matching lines @@
 }
 
 ChildProcessLauncher::Client* ChildProcessLauncher::ReplaceClientForTest(
     Client* client) {
   Client* ret = client_;
   client_ = client;
   return ret;
 }
 
 }  // namespace content