Make Mac first run store sentinel in Profile directory.

chrome/app/breakpad_linux.cc

 // Copyright (c) 2009 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/app/breakpad_linux.h"
 
 #include <arpa/inet.h>
 #include <fcntl.h>
 #include <netinet/in.h>
 #include <sys/sendfile.h>
@@ skipping 454 matching lines @@
     sys__exit(1);
   }
 
   return child;
 }
 
 // This is defined in chrome/browser/google_update_settings_linux.cc, it's the
 // static string containing the user's unique GUID. We send this in the crash
 // report.
 namespace google_update {
-extern std::string linux_guid;
+extern std::string posix_guid;
 }
 
 // This is defined in base/linux_util.cc, it's the static string containing the
 // user's distro info. We send this in the crash report.
 namespace base {
 extern std::string linux_distro;
 }
 
 static bool CrashDone(const char* dump_path,
                       const char* minidump_id,
@@ skipping 15 matching lines @@
   memcpy(path + dump_path_len + 1, minidump_id, minidump_id_len);
   memcpy(path + dump_path_len + 1 + minidump_id_len, ".dmp", 4);
   path[dump_path_len + 1 + minidump_id_len + 4] = 0;
 
   BreakpadInfo info;
   info.filename = path;
   info.process_type = "browser";
   info.process_type_length = 7;
   info.crash_url = NULL;
   info.crash_url_length = 0;
-  info.guid = google_update::linux_guid.data();
-  info.guid_length = google_update::linux_guid.length();
+  info.guid = google_update::posix_guid.data();
+  info.guid_length = google_update::posix_guid.length();
   info.distro = base::linux_distro.data();
   info.distro_length = base::linux_distro.length();
   UploadCrashDump(info);
 
   return true;
 }
 
 void EnableCrashDumping() {
   // We leak this object.
 
@@ skipping 10 matching lines @@
 
 static bool
 RendererCrashHandler(const void* crash_context, size_t crash_context_size,
              void* context) {
   const int fd = reinterpret_cast<intptr_t>(context);
   int fds[2];
   socketpair(AF_UNIX, SOCK_STREAM, 0, fds);
   char guid[kGuidSize] = {0};
   char crash_url[kMaxActiveURLSize + 1] = {0};
   char distro[kDistroSize + 1] = {0};
-  const size_t guid_len = std::min(google_update::linux_guid.size(),
+  const size_t guid_len = std::min(google_update::posix_guid.size(),
                                    kGuidSize);
   const size_t crash_url_len =
       std::min(child_process_logging::active_url.size(), kMaxActiveURLSize);
   const size_t distro_len =
       std::min(base::linux_distro.size(), kDistroSize);
-  memcpy(guid, google_update::linux_guid.data(), guid_len);
+  memcpy(guid, google_update::posix_guid.data(), guid_len);
   memcpy(crash_url, child_process_logging::active_url.data(), crash_url_len);
   memcpy(distro, base::linux_distro.data(), distro_len);
 
   // The length of the control message:
   static const unsigned kControlMsgSize = CMSG_SPACE(sizeof(int));
 
   struct kernel_msghdr msg;
   my_memset(&msg, 0, sizeof(struct kernel_msghdr));
   struct kernel_iovec iov[4];
   iov[0].iov_base = const_cast<void*>(crash_context);
@@ skipping 51 matching lines @@
     // We might be chrooted in a zygote or renderer process so we cannot call
     // GetCollectStatsConsent because that needs access the the user's home
     // dir. Instead, we set a command line flag for these processes.
     if (!parsed_command_line.HasSwitch(switches::kEnableCrashReporter))
       return;
     // Get the guid and linux distro from the command line switch.
     std::string switch_value = WideToASCII(
         parsed_command_line.GetSwitchValue(switches::kEnableCrashReporter));
     size_t separator = switch_value.find(",");
     if (separator != std::string::npos) {
-      google_update::linux_guid = switch_value.substr(0, separator);
+      google_update::posix_guid = switch_value.substr(0, separator);
       base::linux_distro = switch_value.substr(separator + 1);
     } else {
-      google_update::linux_guid = switch_value;
+      google_update::posix_guid = switch_value;
     }
     EnableRendererCrashDumping();
   }
 }
 
 // -----------------------------------------------------------------------------
 
 bool EnableCoreDumping(std::string* core_dump_directory) {
   // First we check that the core files will get dumped to the
   // current-directory in a file called 'core'. We could try to support other
@@ skipping 145 matching lines @@
   }
 
   if (WIFSIGNALED(status) && WCOREDUMP(status)) {
     std::string core_filename;
     UploadCoreFile(child, &core_filename);
     unlink(core_filename.c_str());
   }
 
   rmdir(core_dump_directory.c_str());
 }