Files required by a service now listed in manifest.

content/app/content_main_runner.cc

 // Copyright (c) 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/public/app/content_main_runner.h"
 
 #include <stddef.h>
 #include <stdlib.h>
 #include <string.h>
 
@@ skipping 34 matching lines @@
 #include "components/tracing/browser/trace_config_file.h"
 #include "components/tracing/common/trace_to_console.h"
 #include "components/tracing/common/tracing_switches.h"
 #include "content/app/mojo/mojo_init.h"
 #include "content/common/set_process_title.h"
 #include "content/common/url_schemes.h"
 #include "content/public/app/content_main.h"
 #include "content/public/app/content_main_delegate.h"
 #include "content/public/common/content_client.h"
 #include "content/public/common/content_constants.h"
+#include "content/public/common/content_descriptor_keys.h"
 #include "content/public/common/content_paths.h"
 #include "content/public/common/content_switches.h"
 #include "content/public/common/main_function_params.h"
 #include "content/public/common/sandbox_init.h"
 #include "ipc/ipc_descriptors.h"
 #include "media/base/media.h"
 #include "ppapi/features/features.h"
+#include "services/service_manager/public/cpp/shared_file_util.h"
 #include "ui/base/ui_base_paths.h"
 #include "ui/base/ui_base_switches.h"
 
 #if defined(V8_USE_EXTERNAL_STARTUP_DATA) && \
     !defined(CHROME_MULTIPLE_DLL_BROWSER)
 #include "gin/v8_initializer.h"
 #endif
 
 #if defined(OS_WIN)
 #include <malloc.h>
 #include <cstring>
 
 #include "base/trace_event/trace_event_etw_export_win.h"
 #include "base/win/process_startup_helper.h"
 #include "sandbox/win/src/sandbox_types.h"
 #include "ui/base/win/atl_module.h"
 #include "ui/display/win/dpi.h"
 #elif defined(OS_MACOSX)
 #include "base/allocator/allocator_shim.h"
 #include "base/mac/scoped_nsautorelease_pool.h"
 #include "base/power_monitor/power_monitor_device_source.h"
 #include "content/app/mac/mac_init.h"
 #include "content/browser/mach_broker_mac.h"
 #include "content/common/sandbox_init_mac.h"
 #endif  // OS_WIN
 
 #if defined(OS_POSIX)
 #include <signal.h>
 
+#include "base/file_descriptor_store.h"
 #include "base/posix/global_descriptors.h"
 #include "content/public/common/content_descriptors.h"
 
 #if !defined(OS_MACOSX)
 #include "content/public/common/zygote_fork_delegate_linux.h"
 #endif
 #if !defined(OS_MACOSX) && !defined(OS_ANDROID)
 #include "content/zygote/zygote_main.h"
 #endif
 
@@ skipping 39 matching lines @@
 extern int RendererMain(const content::MainFunctionParams&);
 extern int UtilityMain(const MainFunctionParams&);
 }  // namespace content
 
 namespace content {
 
 namespace {
 
 #if defined(V8_USE_EXTERNAL_STARTUP_DATA) && defined(OS_ANDROID)
 #if defined __LP64__
-#define kV8SnapshotDataDescriptor kV8SnapshotDataDescriptor64
+#define kV8SnapshotDataDescriptor kV8Snapshot64DataDescriptor
 #else
-#define kV8SnapshotDataDescriptor kV8SnapshotDataDescriptor32
+#define kV8SnapshotDataDescriptor kV8Snapshot32DataDescriptor
 #endif
 #endif
 
 // This sets up two singletons responsible for managing field trials. The
 // |field_trial_list| singleton lives on the stack and must outlive the Run()
 // method of the process.
 void InitializeFieldTrialAndFeatureList(
     std::unique_ptr<base::FieldTrialList>* field_trial_list) {
   const base::CommandLine& command_line =
       *base::CommandLine::ForCurrentProcess();
@@ skipping 24 matching lines @@
 }
 
 void InitializeV8IfNeeded(
     const base::CommandLine& command_line,
     const std::string& process_type) {
   if (process_type == switches::kGpuProcess)
     return;
 
 #if defined(V8_USE_EXTERNAL_STARTUP_DATA)
 #if defined(OS_POSIX) && !defined(OS_MACOSX)
-  base::GlobalDescriptors* g_fds = base::GlobalDescriptors::GetInstance();
-#if !defined(OS_ANDROID)
-    // kV8NativesDataDescriptor and kV8SnapshotDataDescriptor could be shared
-    // with child processes via file descriptors. On Android they are set in
-    // ChildProcessService::InternalInitChildProcess, otherwise set them here.
-    if (command_line.HasSwitch(switches::kV8NativesPassedByFD)) {
-      g_fds->Set(
-          kV8NativesDataDescriptor,
-          kV8NativesDataDescriptor + base::GlobalDescriptors::kBaseDescriptor);
-    }
-    if (command_line.HasSwitch(switches::kV8SnapshotPassedByFD)) {
-      g_fds->Set(
-          kV8SnapshotDataDescriptor,
-          kV8SnapshotDataDescriptor + base::GlobalDescriptors::kBaseDescriptor);
-    }
-#endif  // !OS_ANDROID
-    int v8_natives_fd = g_fds->MaybeGet(kV8NativesDataDescriptor);
-    int v8_snapshot_fd = g_fds->MaybeGet(kV8SnapshotDataDescriptor);
-    if (v8_snapshot_fd != -1) {
-      auto v8_snapshot_region = g_fds->GetRegion(kV8SnapshotDataDescriptor);
-      gin::V8Initializer::LoadV8SnapshotFromFD(
-          v8_snapshot_fd, v8_snapshot_region.offset, v8_snapshot_region.size);
+  base::FileDescriptorStore& file_descriptor_store =
+      base::FileDescriptorStore::GetInstance();
+  base::MemoryMappedFile::Region region;
+  base::ScopedFD v8_snapshot_fd =
+      file_descriptor_store.MaybeTakeFD(kV8SnapshotDataDescriptor, &region);
+  if (v8_snapshot_fd.is_valid()) {
+    gin::V8Initializer::LoadV8SnapshotFromFD(v8_snapshot_fd.get(),
+                                             region.offset, region.size);
     } else {
       gin::V8Initializer::LoadV8Snapshot();
     }
-    if (v8_natives_fd != -1) {
-      auto v8_natives_region = g_fds->GetRegion(kV8NativesDataDescriptor);
-      gin::V8Initializer::LoadV8NativesFromFD(
-          v8_natives_fd, v8_natives_region.offset, v8_natives_region.size);
+    base::ScopedFD v8_natives_fd =
+        file_descriptor_store.MaybeTakeFD(kV8NativesDataDescriptor, &region);
+    if (v8_natives_fd.is_valid()) {
+      gin::V8Initializer::LoadV8NativesFromFD(v8_natives_fd.get(),
+                                              region.offset, region.size);
     } else {
       gin::V8Initializer::LoadV8Natives();
     }
 #else
 #if !defined(CHROME_MULTIPLE_DLL_BROWSER)
     gin::V8Initializer::LoadV8Snapshot();
     gin::V8Initializer::LoadV8Natives();
 #endif  // !CHROME_MULTIPLE_DLL_BROWSER
 #endif  // OS_POSIX && !OS_MACOSX
 #endif  // V8_USE_EXTERNAL_STARTUP_DATA
@@ skipping 32 matching lines @@
       {SIGHUP, SIGINT, SIGQUIT, SIGILL, SIGABRT, SIGFPE, SIGSEGV,
        SIGALRM, SIGTERM, SIGCHLD, SIGBUS, SIGTRAP};  // SIGPIPE is set below.
   for (unsigned i = 0; i < arraysize(signals_to_reset); i++) {
     CHECK_EQ(0, sigaction(signals_to_reset[i], &sigact, NULL));
   }
 
   // Always ignore SIGPIPE.  We check the return value of write().
   CHECK_NE(SIG_ERR, signal(SIGPIPE, SIG_IGN));
 }
 
+void PopulateFDsFromCommandLine() {
+  const std::string& shared_file_param =
+      base::CommandLine::ForCurrentProcess()->GetSwitchValueASCII(
+          switches::kSharedFiles);
+  if (shared_file_param.empty())
+    return;
+
+  base::Optional<std::map<int, std::string>> shared_file_descriptors =
+      service_manager::ParseSharedFileSwitchValue(shared_file_param);
+  if (!shared_file_descriptors)
+    return;
+
+  for (const auto& descriptor : *shared_file_descriptors) {
+    base::MemoryMappedFile::Region region;
+    const std::string& key = descriptor.second;
+    base::ScopedFD fd = base::GlobalDescriptors::GetInstance()->TakeFD(
+        descriptor.first, &region);
+    base::FileDescriptorStore::GetInstance().Set(key, std::move(fd), region);
+  }
+}
+
 #endif  // OS_POSIX
 
 void CommonSubprocessInit() {
 #if defined(OS_WIN)
   // HACK: Let Windows know that we have started.  This is needed to suppress
   // the IDC_APPSTARTING cursor from being displayed for a prolonged period
   // while a subprocess is starting.
   PostThreadMessage(GetCurrentThreadId(), WM_NULL, 0, 0);
   MSG msg;
   PeekMessage(&msg, NULL, 0, 0, PM_REMOVE);
@@ skipping 302 matching lines @@
 
 #if defined(OS_MACOSX)
     // We need this pool for all the objects created before we get to the
     // event loop, but we don't want to leave them hanging around until the
     // app quits. Each "main" needs to flush this pool right before it goes into
     // its main event loop to get rid of the cruft.
     autorelease_pool_.reset(new base::mac::ScopedNSAutoreleasePool());
     InitializeMac();
 #endif
 
-    // On Android, the command line is initialized when library is loaded and
-    // we have already started our TRACE_EVENT0.
+// On Android, the command line is initialized and the FDs set when the
+// library is loaded and we have already started our TRACE_EVENT0.
 #if !defined(OS_ANDROID)
     // argc/argv are ignored on Windows and Android; see command_line.h for
     // details.
     int argc = 0;
     const char** argv = NULL;
 
 #if !defined(OS_WIN)
     argc = params.argc;
     argv = params.argv;
 #endif
 
     base::CommandLine::Init(argc, argv);
 
+#if defined(OS_POSIX)
+    PopulateFDsFromCommandLine();
+#endif
+
     base::EnableTerminationOnHeapCorruption();
 
     // TODO(yiyaoliu, vadimt): Remove this once crbug.com/453640 is fixed.
     // Enable profiler recording right after command line is initialized so that
     // browser startup can be instrumented.
     if (delegate_ && delegate_->ShouldEnableProfilerRecording())
       tracked_objects::ScopedTracker::Enable();
 
     SetProcessTitleFromCommandLine(argv);
 #endif  // !OS_ANDROID
@@ skipping 277 matching lines @@
 
   DISALLOW_COPY_AND_ASSIGN(ContentMainRunnerImpl);
 };
 
 // static
 ContentMainRunner* ContentMainRunner::Create() {
   return new ContentMainRunnerImpl();
 }
 
 }  // namespace content