Use a valid /prefetch argument when launching a process.

chrome/app/chrome_exe_main_win.cc

 // Copyright (c) 2011 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 <windows.h>
 #include <malloc.h>
 #include <shellscalingapi.h>
 #include <stddef.h>
 #include <tchar.h>
 
 #include <algorithm>
 #include <string>
 
 #include "base/at_exit.h"
 #include "base/command_line.h"
 #include "base/files/file_path.h"
 #include "base/lazy_instance.h"
 #include "base/logging.h"
 #include "base/macros.h"
+#include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/time/time.h"
 #include "base/win/windows_version.h"
 #include "chrome/app/chrome_crash_reporter_client.h"
 #include "chrome/app/main_dll_loader_win.h"
+#include "chrome/app/prefetch_argument_win.h"
 #include "chrome/browser/chrome_process_finder_win.h"
 #include "chrome/browser/policy/policy_path_parser.h"
 #include "chrome/common/chrome_paths_internal.h"
 #include "chrome/common/chrome_switches.h"
+#include "chrome/installer/util/browser_distribution.h"
 #include "chrome_elf/chrome_elf_main.h"
 #include "components/crash/content/app/crash_reporter_client.h"
 #include "components/crash/content/app/crashpad.h"
 #include "components/startup_metric_utils/browser/startup_metric_utils.h"
+#include "components/startup_metric_utils/common/pre_read_field_trial_utils_win.h"
 #include "content/public/common/content_switches.h"
 #include "content/public/common/result_codes.h"
 #include "third_party/crashpad/crashpad/handler/handler_main.h"
 #include "ui/gfx/win/dpi.h"
 
 namespace {
 
 base::LazyInstance<ChromeCrashReporterClient>::Leaky g_chrome_crash_client =
     LAZY_INSTANCE_INITIALIZER;
 
@@ skipping 102 matching lines @@
   argv.erase(std::remove_if(argv.begin(), argv.end(),
                             [&process_type](const base::string16& str) {
                               return str.compare(0, process_type.size(),
                                                  process_type) == 0;
                             }),
              argv.end());
 
   scoped_ptr<char* []> argv_as_utf8(new char*[argv.size() + 1]);
   std::vector<std::string> storage;
   storage.reserve(argv.size());
+
+  size_t arg_append_index = 0;
   for (size_t i = 0; i < argv.size(); ++i) {
+    // Remove the /prefetch:# argument as it is not supported by Crashpad.
+    if (base::StartsWith(argv[i], L"/prefetch:", base::CompareCase::SENSITIVE))
+      continue;
+
     storage.push_back(base::UTF16ToUTF8(argv[i]));
-    argv_as_utf8[i] = &storage[i][0];
+    argv_as_utf8[arg_append_index] = &storage[arg_append_index][0];
+    ++arg_append_index;
   }
-  argv_as_utf8[argv.size()] = nullptr;
-  return crashpad::HandlerMain(static_cast<int>(argv.size()),
+  DCHECK_EQ(storage.size(), arg_append_index);

[gab, 2016/01/26 21:40:25]

Don't think this DCHECK is necessary, it's pretty obvious.

[fdoray, 2016/01/27 20:12:19]

Done.

+  argv_as_utf8[arg_append_index] = nullptr;
+
+  return crashpad::HandlerMain(static_cast<int>(storage.size()),
                                argv_as_utf8.get());
 }
 
 }  // namespace
 
 // This helper is looked up in the browser to retrieve the crash reports. See
 // CrashUploadListCrashpad. Note that we do not pass an std::vector here,
 // because we do not want to allocate/free in different modules. The returned
 // pointer is read-only.
 extern "C" __declspec(dllexport) void GetUploadedReportsImpl(
     const crash_reporter::UploadedReport** reports,
     size_t* report_count) {
   crash_reporter::GetUploadedReports(g_uploaded_reports.Pointer());
   *reports = g_uploaded_reports.Pointer()->data();
   *report_count = g_uploaded_reports.Pointer()->size();
 }
 
 #if !defined(WIN_CONSOLE_APP)
 int APIENTRY wWinMain(HINSTANCE instance, HINSTANCE prev, wchar_t*, int) {
 #else
 int main() {
   HINSTANCE instance = GetModuleHandle(nullptr);
 #endif
   // Initialize the CommandLine singleton from the environment.
   base::CommandLine::Init(0, nullptr);
+  const base::CommandLine* command_line =
+      base::CommandLine::ForCurrentProcess();
 
-  std::string process_type =
-      base::CommandLine::ForCurrentProcess()->GetSwitchValueASCII(
-          switches::kProcessType);
+  const std::string process_type =
+      command_line->GetSwitchValueASCII(switches::kProcessType);
+
+  startup_metric_utils::InitializePreReadOptions(
+      BrowserDistribution::GetDistribution()->GetRegistryPath());
+  DCHECK(!startup_metric_utils::GetPreReadOptions().prefetch_argument ||

[gab, 2016/01/26 21:40:25]

Add a comment about what this DCHECK verifies, e.g.:

// Confirm that an explicit prefetch profile is used for all process types
except for the browser process (apart from background mode which is assigned an
explicit prefetch profile as well). Any new process type will have to assign
itself a prefetch profile (see foo.h for details).

[gab, 2016/01/26 21:40:25]

Reading this here makes me realize that |prefetch_argument| doesn't feel like a
bool, but instead like some kind of property, whereas |use_prefetch_argument|
would be obvious and not require the reader to double-check that API while
reading this code.

[fdoray, 2016/01/27 20:12:19]

Done.

[fdoray, 2016/01/27 20:12:19]

Done.

+         (process_type.empty() &&
+          !command_line->HasSwitch(switches::kNoStartupWindow)) ||

[gab, 2016/01/26 21:40:25]

This will DCHECK on any existing install which uses background mode as the
registry isn't updated by this CL (only future commands dropped in  registry).

Perhaps it's okay to ignore background mode in this DCHECK since it's mostly
meant to catch regressions for new process types (or catch ones we may have
forgotten in this one).

[fdoray, 2016/01/27 20:12:19]

Done. Note: According to my debugging, the background mode autorun entry is
updated by [1] every time Chrome is launched. With my previous DCHECK, the user
only had to run Chrome once in non-background mode to eliminate the failure (and
I guess few people have an autorun entry for a debug build of Chrome?).

[1]
https://code.google.com/p/chromium/codesearch#chromium/src/chrome/installer/u...

[gab, 2016/01/29 12:46:25]

Hmmm, are you sure this code kicks in on every startup? FWICT the way it's
written it's only meant to kick in on state change.

[fdoray, 2016/01/29 15:33:30]

When I have a background app installed,
BackgroundModeManager::OnApplicationListChanged is called and the registry is
updated on every startup.

Stack:
  BackgroundModeManager::EnableLaunchOnStartup
  BackgroundModeManager::OnClientsChanged
  BackgroundModeManager::OnApplicationListChanged
  BackgroundApplicationListModel::Update
  BackgroundApplicationListModel::Observe
  content::NotificationServiceImpl::Notify
  BackgroundContentsService::SendChangeNotification
  BackgroundContentsService::Observe
  content::NotificationServiceImpl::Notify
  ExtensionService::SetReadyAndNotifyListeners
  ExtensionService::Init
  ...

[gab, 2016/01/29 19:39:28]

Interesting, this is certainly unexpected for me and I doubt this is
intentional. The code handling the notification really seems to be handling a
change in state. 

In particular, BackgroundContentsService::Observe() is reacting to
NOTIFICATION_EXTENSIONS_READY_DEPRECATED :-(.

Anyways, in this case it works out in our favor I guess...

+         HasValidWindowsPrefetchArgument(*command_line));
 
   if (process_type == switches::kCrashpadHandler)
     return RunAsCrashpadHandler(*base::CommandLine::ForCurrentProcess());
 
   crash_reporter::SetCrashReporterClient(g_chrome_crash_client.Pointer());
   crash_reporter::InitializeCrashpad(process_type.empty(), process_type);
 
   SwitchToLFHeap();
 
   startup_metric_utils::RecordExeMainEntryPointTime(base::Time::Now());
 
   // Signal Chrome Elf that Chrome has begun to start.
   SignalChromeElf();
 
   // The exit manager is in charge of calling the dtors of singletons.
   base::AtExitManager exit_manager;
 
   // We don't want to set DPI awareness on pre-Win7 because we don't support
   // DirectWrite there. GDI fonts are kerned very badly, so better to leave
   // DPI-unaware and at effective 1.0. See also ShouldUseDirectWrite().
   if (base::win::GetVersion() >= base::win::VERSION_WIN7)
     EnableHighDPISupport();
 
-  if (AttemptFastNotify(*base::CommandLine::ForCurrentProcess()))
+  if (AttemptFastNotify(*command_line))
     return 0;
 
   // Load and launch the chrome dll. *Everything* happens inside.
   VLOG(1) << "About to load main DLL.";
   MainDllLoader* loader = MakeMainDllLoader();
   int rc = loader->Launch(instance);
   loader->RelaunchChromeBrowserWithNewCommandLineIfNeeded();
   delete loader;
   return rc;
 }