Simplifying ContentBrowserClient::GetAdditionalMappedFiles...()

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 <memory>
 #include <utility>
 
 #include "base/bind.h"
@@ skipping 156 matching lines @@
   if (field_trial_handle != base::kInvalidPlatformFile)
     files_to_register->Share(kFieldTrialDescriptor, field_trial_handle);
 #if defined(OS_ANDROID)
   files_to_register->Share(kMojoIPCChannel, mojo_fd.get());
 #else
   files_to_register->Transfer(kMojoIPCChannel, std::move(mojo_fd));
 #endif
 #endif
 
 #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
-      );
+      *cmd_line, child_process_id, files_to_register.get());
 #if defined(V8_USE_EXTERNAL_STARTUP_DATA)
   bool snapshot_loaded = false;
+  base::MemoryMappedFile::Region region;
 #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));
-    }
+  auto maybe_register = [&region, &files_to_register](int key, int fd) {
+    if (fd != -1)
+      files_to_register->ShareWithRegion(key, fd, region);
   };
   maybe_register(
       kV8NativesDataDescriptor,
       gin::V8Initializer::GetOpenNativesFileForChildProcesses(&region));
   maybe_register(
       kV8SnapshotDataDescriptor32,
       gin::V8Initializer::GetOpenSnapshotFileForChildProcesses(&region, true));
   maybe_register(
       kV8SnapshotDataDescriptor64,
       gin::V8Initializer::GetOpenSnapshotFileForChildProcesses(&region, false));
 
   snapshot_loaded = true;
 #else
   base::PlatformFile natives_pf =
-      gin::V8Initializer::GetOpenNativesFileForChildProcesses(
-          &regions[kV8NativesDataDescriptor]);
+      gin::V8Initializer::GetOpenNativesFileForChildProcesses(&region);
   DCHECK_GE(natives_pf, 0);
-  files_to_register->Share(kV8NativesDataDescriptor, natives_pf);
+  files_to_register->ShareWithRegion(
+      kV8NativesDataDescriptor, natives_pf, region);
 
-  base::MemoryMappedFile::Region snapshot_region;
   base::PlatformFile snapshot_pf =
-      gin::V8Initializer::GetOpenSnapshotFileForChildProcesses(
-          &snapshot_region);
+      gin::V8Initializer::GetOpenSnapshotFileForChildProcesses(&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));
+    files_to_register->ShareWithRegion(
+        kV8SnapshotDataDescriptor, snapshot_pf, region);
   }
 #endif
 
   if (process_type != switches::kZygoteProcess) {
     cmd_line->AppendSwitch(::switches::kV8NativesPassedByFD);
     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)
 #if ICU_UTIL_DATA_IMPL == ICU_UTIL_DATA_FILE
-  files_to_register->Share(
-      kAndroidICUDataDescriptor,
-      base::i18n::GetIcuDataFileHandle(&regions[kAndroidICUDataDescriptor]));
+  base::MemoryMappedFile::Region icu_region;
+  base::PlatformFile icu_pf = base::i18n::GetIcuDataFileHandle(&icu_region);
+  files_to_register->ShareWithRegion(
+      kAndroidICUDataDescriptor, icu_pf, icu_region);
 #endif  // ICU_UTIL_DATA_IMPL == ICU_UTIL_DATA_FILE
 
   // Android WebView runs in single process, ensure that we never get here
   // when running in single process mode.
   CHECK(!cmd_line->HasSwitch(switches::kSingleProcess));
 
   StartChildProcess(
-      cmd_line->argv(), child_process_id, std::move(files_to_register), regions,
+      cmd_line->argv(), child_process_id, std::move(files_to_register),
       base::Bind(&OnChildProcessStartedAndroid, callback, client_thread_id,
                  begin_launch_time, base::Passed(&mojo_fd)));
 
 #elif defined(OS_POSIX)
   // We need to close the client end of the IPC channel to reliably detect
   // child termination.
 
 #if !defined(OS_MACOSX)
   ZygoteHandle* zygote_handle =
       !base::CommandLine::ForCurrentProcess()->HasSwitch(switches::kNoZygote)
@@ skipping 347 matching lines @@
 }
 
 ChildProcessLauncher::Client* ChildProcessLauncher::ReplaceClientForTest(
     Client* client) {
   Client* ret = client_;
   client_ = client;
   return ret;
 }
 
 }  // namespace content