Remove PRODUCT_STRING_PATH from chrome_constants.h on Windows.

chrome/chrome_watcher/chrome_watcher_main.cc

 // Copyright (c) 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 <windows.h>
 #include <sddl.h>
 
 #include "base/at_exit.h"
 #include "base/bind.h"
 #include "base/bind_helpers.h"
@@ skipping 41 matching lines @@
         { 0x80, 0xc1, 0x52, 0x7f, 0xea, 0x23, 0xe3, 0xa7 } };
 
 // The amount of time we wait around for a WM_ENDSESSION or a process exit.
 const int kDelayTimeSeconds = 30;
 
 // Takes care of monitoring a browser. This class watches for a browser's exit
 // code, as well as listening for WM_ENDSESSION messages. Events are recorded in
 // an exit funnel, for reporting the next time Chrome runs.
 class BrowserMonitor {
  public:
-  BrowserMonitor(base::RunLoop* run_loop, const base::char16* registry_path);
+  BrowserMonitor(const base::string16& registry_path, base::RunLoop* run_loop);
   ~BrowserMonitor();
 
   // Initiates the asynchronous monitoring process, returns true on success.
   // |on_initialized_event| will be signaled immediately before blocking on the
   // exit of |process|.
-  bool StartWatching(const base::char16* registry_path,
-                     base::Process process,
+  bool StartWatching(base::Process process,
                      base::win::ScopedHandle on_initialized_event);
 
  private:
   // Called from EndSessionWatcherWindow on a end session messages.
   void OnEndSessionMessage(UINT message, LPARAM lparam);
 
   // Blocking function that runs on |background_thread_|. Signals
   // |on_initialized_event| before waiting for the browser process to exit.
   void Watch(base::win::ScopedHandle on_initialized_event);
 
@@ skipping 10 matching lines @@
   // when WM_ENDSESSION occurs before browser exit.
   base::WaitableEvent browser_exited_;
 
   // The run loop for the main thread and its task runner.
   base::RunLoop* run_loop_;
   scoped_refptr<base::SequencedTaskRunner> main_thread_;
 
   DISALLOW_COPY_AND_ASSIGN(BrowserMonitor);
 };
 
-BrowserMonitor::BrowserMonitor(base::RunLoop* run_loop,
-                               const base::char16* registry_path)
+BrowserMonitor::BrowserMonitor(const base::string16& registry_path,
+                               base::RunLoop* run_loop)
     : exit_code_watcher_(registry_path),
       end_session_watcher_window_(
           base::Bind(&BrowserMonitor::OnEndSessionMessage,
                      base::Unretained(this))),
       background_thread_("BrowserWatcherThread"),
       browser_exited_(true, false),  // manual reset, initially non-signalled.
       run_loop_(run_loop),
       main_thread_(base::ThreadTaskRunnerHandle::Get()) {
 }
 
 BrowserMonitor::~BrowserMonitor() {
 }
 
 bool BrowserMonitor::StartWatching(
-    const base::char16* registry_path,
     base::Process process,
     base::win::ScopedHandle on_initialized_event) {
   if (!exit_code_watcher_.Initialize(process.Pass()))
     return false;
 
   if (!background_thread_.StartWithOptions(
         base::Thread::Options(base::MessageLoop::TYPE_IO, 0))) {
     return false;
   }
 
@@ skipping 51 matching lines @@
     // The browser exited abnormally, wait around for a little bit to see
     // whether this instance will get a logoff message.
     main_thread_->PostDelayedTask(
         FROM_HERE,
         run_loop_->QuitClosure(),
         base::TimeDelta::FromSeconds(kDelayTimeSeconds));
   }
 }
 
 void OnWindowEvent(
-    const base::string16& registry_path,
     base::Process process,
     const base::Callback<void(const base::Process&)>& on_hung_callback,
     browser_watcher::WindowHangMonitor::WindowEvent window_event) {
   if (window_event == browser_watcher::WindowHangMonitor::WINDOW_HUNG &&
       !on_hung_callback.is_null()) {
     on_hung_callback.Run(process);
   }
 }
 
 #if BUILDFLAG(ENABLE_KASKO)
@@ skipping 143 matching lines @@
 
   // TODO(erikwright): Copy minidump to some "last dump" location?
 }
 
 #endif  // BUILDFLAG(ENABLE_KASKO)
 
 }  // namespace
 
 // The main entry point to the watcher, declared as extern "C" to avoid name
 // mangling.
-extern "C" int WatcherMain(const base::char16* registry_path,
+extern "C" int WatcherMain(const base::string16& registry_path,

[Sigurður Ásgeirsson, 2016/01/25 20:50:24]

this crosses a module boundary and hence an allocation boundary. We pass only
PODs across those, hence the char16*

[gab, 2016/01/26 02:55:05]

Gotcha, would a base::string16* be okay? i.e given the call is synchronous and
the memory would be forever valid, right?

In fact the classes (BrowserMonitor et al.) could store a const base::string16*
instead of copying it to a local base::string16 member.

Another option is to do just that but pass the string through its c_str() as a 
"const base::char16*" and store it as that instead of copying the string?

                            HANDLE process_handle,
                            DWORD main_thread_id,
                            HANDLE on_initialized_event_handle,
                            const base::char16* browser_data_directory,
                            const base::char16* message_window_name,
                            const base::char16* channel_name) {
   base::Process process(process_handle);
   base::win::ScopedHandle on_initialized_event(on_initialized_event_handle);
 
   // The exit manager is in charge of calling the dtors of singletons.
@@ skipping 34 matching lines @@
         base::Bind(&DumpHungBrowserProcess, main_thread_id, channel_name);
   }
 #endif  // BUILDFLAG(ENABLE_KASKO_HANG_REPORTS)
 #endif  // BUILDFLAG(ENABLE_KASKO)
 
   // Run a UI message loop on the main thread.
   base::MessageLoop msg_loop(base::MessageLoop::TYPE_UI);
   msg_loop.set_thread_name("WatcherMainThread");
 
   base::RunLoop run_loop;
-  BrowserMonitor monitor(&run_loop, registry_path);
-  if (!monitor.StartWatching(registry_path, process.Duplicate(),
+  BrowserMonitor monitor(registry_path, &run_loop);
+  if (!monitor.StartWatching(process.Duplicate(),
                              on_initialized_event.Pass())) {
     return 1;
   }
 
   {
     // Scoped to force |hang_monitor| destruction before Kasko is shut down.
     browser_watcher::WindowHangMonitor hang_monitor(
         base::TimeDelta::FromSeconds(60), base::TimeDelta::FromSeconds(20),
-        base::Bind(&OnWindowEvent, registry_path,
-                   base::Passed(process.Duplicate()), on_hung_callback));
+        base::Bind(&OnWindowEvent, base::Passed(process.Duplicate()),
+                   on_hung_callback));
     hang_monitor.Initialize(process.Duplicate(), message_window_name);
 
     run_loop.Run();
   }
 
 #if BUILDFLAG(ENABLE_KASKO)
   if (launched_kasko)
     kasko::api::ShutdownReporter();
 #endif  // BUILDFLAG(ENABLE_KASKO)
 
   // Wind logging down.
   logging::LogEventProvider::Uninitialize();
 
   return 0;
 }
 
 static_assert(
     base::is_same<decltype(&WatcherMain), ChromeWatcherMainFunction>::value,
     "WatcherMain() has wrong type");