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";

[grt (UTC plus 2), 2017/05/17 20:10:36]

#if !defined(DISABLE_NACL)

[manzagop (departed), 2017/05/17 21:15:56]

Done.

+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) {

[grt (UTC plus 2), 2017/05/17 20:10:36]

const&

[manzagop (departed), 2017/05/17 21:15:56]

Err... Done.

+  if (process_type.empty()) {

[grt (UTC plus 2), 2017/05/17 20:10:36]

no braces and no "else":

  if (foo)
    return foo;
  if (bar)
    return bar;

[manzagop (departed), 2017/05/17 21:15:56]

Done.

+    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

[grt (UTC plus 2), 2017/05/17 20:10:36]

nit: Windows

[manzagop (departed), 2017/05/17 21:15:56]

Done.

+  // 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 ||

[grt (UTC plus 2), 2017/05/17 20:10:36]

to protect against future types being added to the enum but not here, i would go
with:
  switch (process_type) {
    case foo:
    case bar:
#if !defined...
    case bletch:
#endif
      return true;
    case theother:
      return false;
  }
  assert(false);
  return false;

by listing every case explicitly and omitting a "default" clause, future
additions to the enum will throw a compile error until this is adjusted
accordingly.

[manzagop (departed), 2017/05/17 21:15:56]

Done. It's just clang that throws an error in that case, right?

+      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)();
-  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;
+  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;
+  return g_process_type != ProcessType::BROWSER_PROCESS;
+}
+
+bool ProcessNeedsProfileDir(const std::string& process_type) {

[grt (UTC plus 2), 2017/05/17 20:10:36]

part of me wants this function to be an export from chrome_elf that is imported
by chrome{,_child}.dll so that it doesn't need to recompute the process type. i
can see that that's a bigger change, though, and isn't really a huge savings.

[manzagop (departed), 2017/05/17 21:15:56]

Acknowledged.

+  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