Fix stats table on linux. There were two problems:...

chrome/app/chrome_dll_main.cc

 // Copyright (c) 2010 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.
 
 // TODO(port): the ifdefs in here are a first step towards trying to determine
 // the correct abstraction for all the OS functionality required at this
 // stage of process initialization. It should not be taken as a final
 // abstraction.
 
 #include "build/build_config.h"
@@ skipping 395 matching lines @@
   } else if (process_type == switches::kUtilityProcess) {
     name_id = IDS_UTILITY_APP_NAME;
   }
   if (name_id) {
     NSString* app_name = l10n_util::GetNSString(name_id);
     mac_util::SetProcessName(reinterpret_cast<CFStringRef>(app_name));
   }
 }
 #endif  // defined(OS_MACOSX)
 
+void InitializeStatsTable(base::ProcessId browser_pid,
+                          const CommandLine & parsed_command_line) {
+  // Initialize the Stats Counters table.  With this initialized,
+  // the StatsViewer can be utilized to read counters outside of
+  // Chrome.  These lines can be commented out to effectively turn
+  // counters 'off'.  The table is created and exists for the life
+  // of the process.  It is not cleaned up.
+  if (parsed_command_line.HasSwitch(switches::kEnableStatsTable) ||
+      parsed_command_line.HasSwitch(switches::kEnableBenchmarking)) {
+    // NOTIMPLEMENTED: we probably need to shut this down correctly to avoid
+    // leaking shared memory regions on posix platforms.
+    std::string statsfile =
+        StringPrintf("%s-%u", chrome::kStatsFilename,
+                     static_cast<unsigned int>(browser_pid));
+    StatsTable *stats_table = new StatsTable(statsfile,
+        chrome::kStatsMaxThreads, chrome::kStatsMaxCounters);
+    StatsTable::set_current(stats_table);
+  }
+}
+
 }  // namespace
 
 #if defined(OS_WIN)
 DLLEXPORT int __cdecl ChromeMain(HINSTANCE instance,
                                  sandbox::SandboxInterfaceInfo* sandbox_info,
                                  TCHAR* command_line) {
 #elif defined(OS_POSIX)
 int ChromeMain(int argc, char** argv) {
 #endif
 #if defined(OS_CHROMEOS)
@@ skipping 123 matching lines @@
 
   base::ProcessId browser_pid = base::GetCurrentProcId();
   if (SubprocessIsBrowserChild(process_type)) {
 #if defined(OS_WIN)
     std::wstring channel_name =
       parsed_command_line.GetSwitchValue(switches::kProcessChannelID);
 
     browser_pid =
         static_cast<base::ProcessId>(StringToInt(WideToASCII(channel_name)));
     DCHECK_NE(browser_pid, 0u);
-#else
+#elif defined(OS_MACOSX)
     browser_pid = base::GetCurrentProcId();
+#elif defined(OS_POSIX)
+    // On linux, we're in the zygote here; so we need the parent process' id.
+    browser_pid = base::GetParentProcessId(base::GetCurrentProcId());
 #endif
 
 #if defined(OS_POSIX)
     // When you hit Ctrl-C in a terminal running the browser
     // process, a SIGINT is delivered to the entire process group.
     // When debugging the browser process via gdb, gdb catches the
     // SIGINT for the browser process (and dumps you back to the gdb
     // console) but doesn't for the child processes, killing them.
     // The fix is to have child processes ignore SIGINT; they'll die
     // on their own when the browser process goes away.
@@ skipping 40 matching lines @@
                                         || mac_util::IsBackgroundOnlyProcess();
     if (!IsCrashReporterEnabled() && disable_apple_crash_reporter) {
       DebugUtil::DisableOSCrashDumps();
     }
   }
 
   if (IsCrashReporterEnabled())
     InitCrashProcessInfo();
 #endif  // OS_MACOSX
 
-  // Initialize the Stats Counters table.  With this initialized,
-  // the StatsViewer can be utilized to read counters outside of
-  // Chrome.  These lines can be commented out to effectively turn
-  // counters 'off'.  The table is created and exists for the life
-  // of the process.  It is not cleaned up.
-  // TODO(port): we probably need to shut this down correctly to avoid
-  // leaking shared memory regions on posix platforms.
-  if (parsed_command_line.HasSwitch(switches::kEnableStatsTable) ||
-      parsed_command_line.HasSwitch(switches::kEnableBenchmarking)) {
-    std::string statsfile =
-        StringPrintf("%s-%u", chrome::kStatsFilename,
-                     static_cast<unsigned int>(browser_pid));
-    StatsTable *stats_table = new StatsTable(statsfile,
-        chrome::kStatsMaxThreads, chrome::kStatsMaxCounters);
-    StatsTable::set_current(stats_table);
-  }
+  InitializeStatsTable(browser_pid, parsed_command_line);
 
   StatsScope<StatsCounterTimer>
       startup_timer(chrome::Counters::chrome_main());
 
   // Enable the heap profiler as early as possible!
   EnableHeapProfiler(parsed_command_line);
 
   // Enable Message Loop related state asap.
   if (parsed_command_line.HasSwitch(switches::kMessageLoopHistogrammer))
     MessageLoop::EnableHistogrammer(true);
@@ skipping 142 matching lines @@
     rv = NaClBrokerMain(main_params);
 #endif
   } else if (process_type == switches::kZygoteProcess) {
 #if defined(OS_POSIX) && !defined(OS_MACOSX)
     // This function call can return multiple times, once per fork().
     if (ZygoteMain(main_params)) {
       // Zygote::HandleForkRequest may have reallocated the command
       // line so update it here with the new version.
       const CommandLine& parsed_command_line =
         *CommandLine::ForCurrentProcess();
+
+      // The StatsTable must be initialized in each process; we already
+      // initialized for the browser process, now we need to initialize
+      // within the new processes as well.
+      InitializeStatsTable(browser_pid, parsed_command_line);

[Evan Martin, 2010/11/22 22:19:22]

Hey, remember this old change?  I am touching this code again for unrelated
reasons and I don't understand this.  We've already initialized the stats table
for the zygote process at L644, and ZygoteMain() will just fork(), so the
subprocess inherits the initialized table here.  Do you remember why you needed
to recreate it?

[Mike Belshe, 2010/11/22 22:30:52]

I can't recall exactly what was broken before - but we want the child to open
the shared memory segment separately from the parent.  Line 644 creates the
shared memory in the browser process, line 811 has each child process open it
and use it as a subscriber.  It seems like a fork should be sufficient, I forget
why that was not the case.

[Evan Martin, 2010/11/22 22:32:31]

Can you advise me how I can test whether my refactoring breaks this?  I run with
--enable-stats-table, and then check that [fill me in].

+
       MainFunctionParams main_params(parsed_command_line, sandbox_wrapper,
                                      &autorelease_pool);
       std::string process_type =
         parsed_command_line.GetSwitchValueASCII(switches::kProcessType);
       if (process_type == switches::kRendererProcess ||
           process_type == switches::kExtensionProcess) {
         rv = RendererMain(main_params);
 #ifndef DISABLE_NACL
       } else if (process_type == switches::kNaClLoaderProcess) {
         rv = NaClMain(main_params);
@@ skipping 74 matching lines @@
 
   logging::CleanupChromeLogging();
 
 #if defined(OS_MACOSX) && defined(GOOGLE_CHROME_BUILD)
   // TODO(mark): See the TODO(mark) above at InitCrashReporter.
   DestructCrashReporter();
 #endif  // OS_MACOSX && GOOGLE_CHROME_BUILD
 
   return rv;
 }