Relocate Windows ProcessNeedsProfileDir to install_static

chrome/install_static/install_util.cc

 // Copyright 2014 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 "chrome/install_static/install_util.h"
 
 #include <windows.h>
 #include <assert.h>
 #include <stdlib.h>
 #include <string.h>
@@ skipping 46 matching lines @@
 
 // TODO(ananta)
 // http://crbug.com/604923
 // These constants are defined in the chrome/installer directory as well. We
 // need to unify them.
 constexpr wchar_t kRegValueAp[] = L"ap";
 constexpr wchar_t kRegValueName[] = L"name";
 constexpr wchar_t kRegValueUsageStats[] = L"usagestats";
 constexpr wchar_t kMetricsReportingEnabled[] = L"MetricsReportingEnabled";
 
+constexpr wchar_t kCloudPrintServiceProcess[] = L"cloud-print-service";
+constexpr wchar_t kNaClBrokerProcess[] = L"nacl-broker";
+constexpr wchar_t kNaClLoaderProcess[] = L"nacl-loader";
+
 void Trace(const wchar_t* format_string, ...) {
   static const int kMaxLogBufferSize = 1024;
   static wchar_t buffer[kMaxLogBufferSize] = {};
 
   va_list args = {};
 
   va_start(args, format_string);
   vswprintf(buffer, kMaxLogBufferSize, format_string, args);
   OutputDebugStringW(buffer);
   va_end(args);
@@ skipping 204 matching lines @@
   }
   if (MatchPattern(value, kChromeChannelBetaPattern) ||
       MatchPattern(value, kChromeChannelBetaX64Pattern)) {
     return kChromeChannelBeta;
   }
   // Else report values with garbage as stable since they will match the stable
   // rules in the update configs.
   return std::wstring();
 }
 
+// Converts a process type specified as a string to the ProcessType enum.
+ProcessType GetProcessType(std::wstring process_type) {
+  if (process_type.empty()) {
+    return ProcessType::BROWSER_PROCESS;
+  } else if (process_type == kCloudPrintServiceProcess) {
+    return ProcessType::CLOUD_PRINT_SERVICE_PROCESS;
+#if !defined(DISABLE_NACL)
+  } else if (process_type == kNaClBrokerProcess) {
+    return ProcessType::NACL_BROKER_PROCESS;
+  } else if (process_type == kNaClLoaderProcess) {
+    return ProcessType::NACL_LOADER_PROCESS;
+#endif
+  } else {
+    return ProcessType::OTHER_PROCESS;
+  }
+}
+
+// Returns whether |process_type| needs the profile directory.
+bool ProcessNeedsProfileDir(ProcessType process_type) {
+  // On windows we don't want subprocesses other than the browser process and
+  // service processes to be able to use the profile directory because if it
+  // lies on a network share the sandbox will prevent us from accessing it.
+
+  if (process_type == ProcessType::BROWSER_PROCESS ||
+      process_type == ProcessType::CLOUD_PRINT_SERVICE_PROCESS) {
+    return true;
+  }
+#if !defined(DISABLE_NACL)
+  if (process_type == ProcessType::kNaClBrokerProcess ||
+      process_type == ProcessType::kNaClLoaderProcess) {
+    return true;
+  }
+#endif
+  return false;
+}
+
 }  // namespace
 
 bool IsSystemInstall() {
   return InstallDetails::Get().system_level();
 }
 
 std::wstring GetChromeInstallSubDirectory() {
   std::wstring result;
   AppendChromeInstallSubDirectory(InstallDetails::Get().mode(),
                                   true /* include_suffix */, &result);
@@ skipping 146 matching lines @@
                              kMetricsReportingEnabled, &value)) {
     *crash_reporting_enabled = (value != 0);
     return true;
   }
 
   return false;
 }
 
 void InitializeProcessType() {
   assert(g_process_type == ProcessType::UNINITIALIZED);
-  typedef bool (*IsSandboxedProcessFunc)();

[scottmg, 2017/05/17 17:58:37]

I don't really know, but I suspect it was only a shorthand way of determining
whether this dll was loaded in the browser. Maybe Robert remembers if there's a
more important reason.

[robertshield, 2017/05/17 18:24:54]

I'm pretty sure that's the long and the short of it though memory has since
faded. Some spelunking suggested that this code originated in the blacklist code
that didn't want to be loaded in non-browser processes. It then migrated here
and still survives. 

Removing the check is fine IFF we know for sure that there are no non-browser
process types that don't have "--type" on the command line.

[manzagop (departed), 2017/05/17 18:59:14]

A quick look at live processes on a windows box shows no other. Is there any
other verification I could do?

[robertshield, 2017/05/17 19:30:05]

This suggests that and empty --process-type value == browser process: 

https://codesearch.chromium.org/chromium/src/chrome/app/chrome_main_delegate....

so I reckon we're good.

-  IsSandboxedProcessFunc is_sandboxed_process_func =
-      reinterpret_cast<IsSandboxedProcessFunc>(
-          ::GetProcAddress(::GetModuleHandle(nullptr), "IsSandboxedProcess"));
-  if (is_sandboxed_process_func && is_sandboxed_process_func()) {
-    g_process_type = ProcessType::NON_BROWSER_PROCESS;
-    return;
-  }
-
-  // TODO(robertshield): Drop the command line check when we drop support for
-  // enabling chrome_elf in unsandboxed processes.
-  const wchar_t* command_line = GetCommandLine();
-  if (command_line && ::wcsstr(command_line, L"--type")) {
-    g_process_type = ProcessType::NON_BROWSER_PROCESS;
-    return;
-  }
-
-  g_process_type = ProcessType::BROWSER_PROCESS;
+  // DO NOT SUBMIT: ask reviewer about the reason for the sandbox check.
+  std::wstring process_type =
+      GetSwitchValueFromCommandLine(::GetCommandLine(), kProcessType);
+  g_process_type = GetProcessType(process_type);
 }
 
 bool IsNonBrowserProcess() {
   assert(g_process_type != ProcessType::UNINITIALIZED);
-  return g_process_type == ProcessType::NON_BROWSER_PROCESS;
+  // DO NOT SUBMIT: validate ProcessType::UNINITIALIZED in condition.
+  return g_process_type != ProcessType::BROWSER_PROCESS &&
+         g_process_type != ProcessType::UNINITIALIZED;

[scottmg, 2017/05/17 17:58:37]

Does this get hit? Wouldn't the assert trigger?

[manzagop (departed), 2017/05/17 18:59:14]

Ah right: I'd mentally interpreted is as DCHECK.

I was wondering whether if the previous logic should be unchanged but no reason.

Done.

+}
+
+bool ProcessNeedsProfileDir(const std::string& process_type) {
+  return ProcessNeedsProfileDir(GetProcessType(UTF8ToUTF16(process_type)));
 }
 
 std::wstring GetCrashDumpLocation() {
   // In order to be able to start crash handling very early and in chrome_elf,
   // we cannot rely on chrome's PathService entries (for DIR_CRASH_DUMPS) being
   // available on Windows. See https://crbug.com/564398.
   std::wstring user_data_dir;
   bool ret = GetUserDataDirectory(&user_data_dir, nullptr);
   assert(ret);
   IgnoreUnused(ret);
@@ skipping 348 matching lines @@
     case ChannelStrategy::ADDITIONAL_PARAMETERS:
       return ChannelFromAdditionalParameters(mode, ap_value);
     case ChannelStrategy::FIXED:
       return mode.default_channel_name;
   }
 
   return std::wstring();
 }
 
 }  // namespace install_static