Files required by a service now listed in manifest.

content/browser/child_process_launcher_helper_posix.cc

 // Copyright 2017 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_helper_posix.h"
 
 #include "base/command_line.h"
+#include "base/lazy_instance.h"
 #include "base/metrics/field_trial.h"
+#include "base/strings/string_number_conversions.h"
+#include "base/strings/string_util.h"
 #include "content/browser/file_descriptor_info_impl.h"
 #include "content/public/browser/content_browser_client.h"
 #include "content/public/common/content_client.h"
 #include "content/public/common/content_descriptors.h"
+#include "content/public/common/content_switches.h"
 #include "mojo/edk/embedder/platform_handle.h"
+#include "services/catalog/public/cpp/manifest_parsing_util.h"
 
 namespace content {
 namespace internal {
 
+namespace {
+
+using OpenedFileMap =
+    std::map<base::FilePath,
+             std::pair<base::PlatformFile, base::MemoryMappedFile::Region>>;
+
+base::LazyInstance<
+    std::map<std::string, std::unique_ptr<catalog::RequiredFileMap>>>
+    g_required_files_by_service = LAZY_INSTANCE_INITIALIZER;
+
+base::LazyInstance<OpenedFileMap> g_opened_files = LAZY_INSTANCE_INITIALIZER;
+
+base::LazyInstance<std::map<std::string, std::string>>
+    g_process_name_to_service_name = LAZY_INSTANCE_INITIALIZER;
+
+base::PlatformFile OpenFileIfNecessary(const base::FilePath& path,
+                                       base::MemoryMappedFile::Region* region) {
+  const auto& iter = g_opened_files.Get().find(path);
+  if (iter != g_opened_files.Get().end()) {
+    *region = iter->second.second;
+    return iter->second.first;
+  }
+  base::File file = OpenFileToShare(path, region);
+  if (!file.IsValid()) {
+    return base::kInvalidPlatformFile;
+  }
+  // g_opened_files becomes the owner of the file descriptor.
+  base::PlatformFile fd = file.TakePlatformFile();
+  g_opened_files.Get()[path] = std::make_pair(fd, *region);
+  return fd;
+}
+
+}  // namespace
+
 std::unique_ptr<FileDescriptorInfo> CreateDefaultPosixFilesToMap(
-    const base::CommandLine& command_line,
     int child_process_id,
-    const mojo::edk::PlatformHandle& mojo_client_handle) {
+    const mojo::edk::PlatformHandle& mojo_client_handle,
+    bool include_service_required_files,
+    const std::string& process_type,
+    base::CommandLine* command_line) {
   std::unique_ptr<FileDescriptorInfo> files_to_register(
       FileDescriptorInfoImpl::Create());
 
   int field_trial_handle = base::FieldTrialList::GetFieldTrialHandle();
   if (field_trial_handle != base::kInvalidPlatformFile)
     files_to_register->Share(kFieldTrialDescriptor, field_trial_handle);
 
   DCHECK(mojo_client_handle.is_valid());
   files_to_register->Share(kMojoIPCChannel, mojo_client_handle.handle);
 
   // TODO(jcivelli): remove this "if defined" by making
   // GetAdditionalMappedFilesForChildProcess a no op on Mac.
 #if !defined(OS_MACOSX)
   GetContentClient()->browser()->GetAdditionalMappedFilesForChildProcess(
-      command_line, child_process_id, files_to_register.get());
+      *command_line, child_process_id, files_to_register.get());
 #endif
 
+  if (!include_service_required_files)
+    return files_to_register;
+
+  // Also include the files specified in the services' manifests.
+  const auto& service_name_iter =
+      g_process_name_to_service_name.Get().find(process_type);
+  CHECK(service_name_iter != g_process_name_to_service_name.Get().end());
+  std::string service_name = service_name_iter->second;
+  const auto& files_iter = g_required_files_by_service.Get().find(service_name);
+  if (files_iter != g_required_files_by_service.Get().end()) {
+    catalog::RequiredFileMap* required_files_map = files_iter->second.get();
+    base::GlobalDescriptors::Key key = kContentDynamicDescriptorStart;
+    std::string switch_value;
+    for (const auto& key_path_iter : *required_files_map) {
+      base::MemoryMappedFile::Region region;
+      base::PlatformFile file =
+          OpenFileIfNecessary(base::FilePath(key_path_iter.second), &region);
+      if (file == base::kInvalidPlatformFile) {
+        LOG(ERROR) << "Ignoring invalid file " << key_path_iter.second;
+        continue;
+      }
+      if (!switch_value.empty()) {
+        switch_value += ",";
+      }
+      switch_value += key_path_iter.first;
+      switch_value += ":";
+      switch_value += base::IntToString(key);
+      files_to_register->ShareWithRegion(key, file, region);
+      key++;
+      DCHECK(key < kContentDynamicDescriptorMax);
+    }
+    command_line->AppendSwitchASCII(switches::kSharedFiles, switch_value);
+  }
+
   return files_to_register;
 }
 
+void SetFilesToShareForServicePosix(
+    const std::string& service_name,
+    std::unique_ptr<catalog::RequiredFileMap> required_files) {
+  if (required_files->empty())
+    return;
+
+  std::map<std::string, std::string>& service_name_resolver =

[Ken Rockot(use gerrit already), 2017/02/09 22:46:13]

nit: move this lazy initialization into the function which actually uses
g_process_name_to_service_name?

[Jay Civelli, 2017/02/09 23:27:00]

Done.

+      g_process_name_to_service_name.Get();
+  if (service_name_resolver.empty()) {
+    // Populate the g_process_name_to_service_name map.
+    // The service names are defined in the JSON manifests, so we don't have a
+    // constant accessible for them.
+    // TODO(jcivelli): remove this map once the service name is accessible from
+    //                 the command line crbug.com/687250
+    service_name_resolver[switches::kRendererProcess] = "content_renderer";
+    service_name_resolver[switches::kGpuProcess] = "content_gpu";
+    service_name_resolver[switches::kPpapiPluginProcess] = "content_plugin";
+    service_name_resolver[switches::kUtilityProcess] = "content_utility";
+  }
+
+  if (!base::StartsWith(service_name, "content",
+                        base::CompareCase::INSENSITIVE_ASCII)) {
+    // Not a content child service, ignore.
+    return;
+  }
+
+  DCHECK(g_required_files_by_service.Get().count(service_name) == 0);
+  g_required_files_by_service.Get()[service_name] = std::move(required_files);
+}
+
 }  // namespace internal
 }  // namespace content