mac: Log a message when restarting crashpad_handler

client/crashpad_client_mac.cc

 // Copyright 2014 The Crashpad Authors. All rights reserved.
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
 // You may obtain a copy of the License at
 //
 //     http://www.apache.org/licenses/LICENSE-2.0
 //
 // Unless required by applicable law or agreed to in writing, software
 // distributed under the License is distributed on an "AS IS" BASIS,
@@ skipping 146 matching lines @@
                      database,
                      url,
                      annotations,
                      arguments,
                      receive_right.Pass(),
                      handler_restarter.get(),
                      false)) {
       return base::mac::ScopedMachSendRight();
     }
 
-    if (handler_restarter && handler_restarter->StartRestartThread(
+    if (handler_restarter &&
+        handler_restarter->StartRestartThread(
             handler, database, url, annotations, arguments)) {
       // The thread owns the object now.
       ignore_result(handler_restarter.release());
     }
 
     // If StartRestartThread() failed, proceed without the ability to restart.
     // handler_restarter will be released when this function returns.
 
     return send_right;
   }
@@ skipping 60 matching lines @@
   //!     Failures include failure to start the handler process and failure to
   //!     rendezvous with it via ChildPortHandshake.
   static bool CommonStart(const base::FilePath& handler,
                           const base::FilePath& database,
                           const std::string& url,
                           const std::map<std::string, std::string>& annotations,
                           const std::vector<std::string>& arguments,
                           base::mac::ScopedMachReceiveRight receive_right,
                           HandlerStarter* handler_restarter,
                           bool restart) {
+    DCHECK(!restart || handler_restarter);
+
     if (handler_restarter) {
       // The port-destroyed notification must be requested each time. It uses
       // a send-once right, so once the notification is received, it won’t be
       // sent again unless re-requested.
       mach_port_t previous;
       kern_return_t kr =
           mach_port_request_notification(mach_task_self(),
                                          receive_right.get(),
                                          MACH_NOTIFY_PORT_DESTROYED,
                                          0,
                                          handler_restarter->notify_port_.get(),
                                          MACH_MSG_TYPE_MAKE_SEND_ONCE,
                                          &previous);
       if (kr != KERN_SUCCESS) {
         MACH_LOG(WARNING, kr) << "mach_port_request_notification";
 
         // This will cause the restart thread to terminate after this restart
         // attempt. There’s no longer any need for it, because no more
         // port-destroyed notifications can be delivered.
         handler_restarter->notify_port_.reset();
       } else {
         base::mac::ScopedMachSendRight previous_owner(previous);
         DCHECK(restart || !previous_owner.is_valid());
       }
 
-      if (handler_restarter->last_start_time_) {
+      if (restart) {
         // If the handler was ever started before, don’t restart it too quickly.
         const uint64_t kNanosecondsPerSecond = 1E9;
         const uint64_t kMinimumStartInterval = 1 * kNanosecondsPerSecond;
 
         const uint64_t earliest_next_start_time =
             handler_restarter->last_start_time_ + kMinimumStartInterval;
         const uint64_t now_time = ClockMonotonicNanoseconds();
         if (earliest_next_start_time > now_time) {
+          const uint64_t sleep_time = earliest_next_start_time - now_time;
+          LOG(INFO) << "restarting handler"
+                    << base::StringPrintf(" in %.3fs",
+                                          static_cast<double>(sleep_time) /
+                                              kNanosecondsPerSecond);
           SleepNanoseconds(earliest_next_start_time - now_time);
+        } else {
+          LOG(INFO) << "restarting handler";
         }
       }
 
       handler_restarter->last_start_time_ = ClockMonotonicNanoseconds();
     }
 
     // Set up the arguments for execve() first. These aren’t needed until
     // execve() is called, but it’s dangerous to do this in a child process
     // after fork().
     ChildPortHandshake child_port_handshake;
@@ skipping 217 matching lines @@
     const base::FilePath& database,
     const std::string& url,
     const std::map<std::string, std::string>& annotations,
     const std::vector<std::string>& arguments,
     bool restartable) {
   DCHECK(!exception_port_.is_valid());
 
   // The “restartable” behavior can only be selected on OS X 10.10 and later. In
   // previous OS versions, if the initial client were to crash while attempting
   // to restart the handler, it would become an unkillable process.
-  base::mac::ScopedMachSendRight exception_port(HandlerStarter::InitialStart(
-      handler,
-      database,
-      url,
-      annotations,
-      arguments,
-      restartable && MacOSXMinorVersion() >= 10));
+  base::mac::ScopedMachSendRight exception_port(
+      HandlerStarter::InitialStart(handler,
+                                   database,
+                                   url,
+                                   annotations,
+                                   arguments,
+                                   restartable && MacOSXMinorVersion() >= 10));
   if (!exception_port.is_valid()) {
     return false;
   }
 
   SetHandlerMachPort(exception_port.Pass());
   return true;
 }
 
 bool CrashpadClient::SetHandlerMachService(const std::string& service_name) {
   base::mac::ScopedMachSendRight exception_port(BootstrapLookUp(service_name));
@@ skipping 23 matching lines @@
       system_crash_reporter_handler(SystemCrashReporterHandler());
 
   // Proceed even if SystemCrashReporterHandler() failed, setting MACH_PORT_NULL
   // to clear the current exception ports.
   if (!SetCrashExceptionPorts(system_crash_reporter_handler.get())) {
     SetCrashExceptionPorts(MACH_PORT_NULL);
   }
 }
 
 }  // namespace crashpad