chromeos: Fix renderer-freezing race during aborted suspend.

chromeos/dbus/power_manager_client.cc

 // Copyright (c) 2012 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 "chromeos/dbus/power_manager_client.h"
 
 #include <stdint.h>
 
 #include <algorithm>
 #include <memory>
@@ skipping 525 matching lines @@
                        << " signal about pending suspend attempt "
                        << proto.suspend_id()
                        << " while still waiting on attempt "
                        << pending_suspend_id_;
     }
 
     pending_suspend_id_ = proto.suspend_id();
     suspend_is_pending_ = true;
     suspending_from_dark_resume_ = in_dark_resume;
     num_pending_suspend_readiness_callbacks_ = 0;
+
     if (suspending_from_dark_resume_)
       FOR_EACH_OBSERVER(Observer, observers_, DarkSuspendImminent());
     else
       FOR_EACH_OBSERVER(Observer, observers_, SuspendImminent());
     base::PowerMonitorDeviceSource::HandleSystemSuspending();
     MaybeReportSuspendReadiness();
   }
 
   void SuspendDoneReceived(dbus::Signal* signal) {
     dbus::MessageReader reader(signal);
     power_manager::SuspendDone proto;
     if (!reader.PopArrayOfBytesAsProto(&proto)) {
       POWER_LOG(ERROR) << "Unable to decode protocol buffer from "
                        << power_manager::kSuspendDoneSignal << " signal";
       return;
     }
 
     const base::TimeDelta duration =
         base::TimeDelta::FromInternalValue(proto.suspend_duration());
     POWER_LOG(EVENT) << "Got " << power_manager::kSuspendDoneSignal
                      << " signal:"
                      << " suspend_id=" << proto.suspend_id()
                      << " duration=" << duration.InSeconds() << " sec";
 
-    if (render_process_manager_delegate_)
+    // RenderProcessManagerDelegate is only notified that suspend is imminent
+    // when readiness is being reported to powerd. If the suspend attempt was
+    // cancelled before then, we shouldn't notify the delegate about completion.
+    const bool cancelled_while_regular_suspend_pending =
+        suspend_is_pending_ && !suspending_from_dark_resume_;
+    if (render_process_manager_delegate_ &&
+        !cancelled_while_regular_suspend_pending)
       render_process_manager_delegate_->SuspendDone();
 
+    // powerd always pairs each SuspendImminent signal with SuspendDone before
+    // starting the next suspend attempt, so we should no longer report
+    // readiness for any in-progress suspend attempts.
+    pending_suspend_id_ = -1;
+    suspend_is_pending_ = false;
+    suspending_from_dark_resume_ = false;
+    num_pending_suspend_readiness_callbacks_ = 0;
+
     FOR_EACH_OBSERVER(
         PowerManagerClient::Observer, observers_, SuspendDone(duration));
     base::PowerMonitorDeviceSource::HandleSystemResumed();
   }
 
   void IdleActionImminentReceived(dbus::Signal* signal) {
     dbus::MessageReader reader(signal);
     power_manager::IdleActionImminent proto;
     if (!reader.PopArrayOfBytesAsProto(&proto)) {
       POWER_LOG(ERROR) << "Unable to decode protocol buffer from "
@@ skipping 121 matching lines @@
         in_dark_resume != suspending_from_dark_resume_)
       return;
 
     num_pending_suspend_readiness_callbacks_--;
     MaybeReportSuspendReadiness();
   }
 
   // Reports suspend readiness to powerd if no observers are still holding
   // suspend readiness callbacks.
   void MaybeReportSuspendReadiness() {
-    if (!suspend_is_pending_ || num_pending_suspend_readiness_callbacks_ > 0)
+    CHECK(suspend_is_pending_);
+
+    if (num_pending_suspend_readiness_callbacks_ > 0)
       return;
 
     std::string method_name;
     int32_t delay_id = -1;
     if (suspending_from_dark_resume_) {
       method_name = power_manager::kHandleDarkSuspendReadinessMethod;
       delay_id = dark_suspend_delay_id_;
     } else {
       method_name = power_manager::kHandleSuspendReadinessMethod;
       delay_id = suspend_delay_id_;
@@ skipping 24 matching lines @@
         dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
         dbus::ObjectProxy::EmptyResponseCallback());
   }
 
   // Origin thread (i.e. the UI thread in production).
   base::PlatformThreadId origin_thread_id_;
 
   dbus::ObjectProxy* power_manager_proxy_;
   base::ObserverList<Observer> observers_;
 
-  // The delay_id_ obtained from the RegisterSuspendDelay request.
+  // The delay ID obtained from the RegisterSuspendDelay request.
   int32_t suspend_delay_id_;
   bool has_suspend_delay_id_;
 
-  // The delay_id_ obtained from the RegisterDarkSuspendDelay request.
+  // The delay ID obtained from the RegisterDarkSuspendDelay request.
   int32_t dark_suspend_delay_id_;
   bool has_dark_suspend_delay_id_;
 
-  // powerd-supplied ID corresponding to an imminent suspend attempt that is
-  // currently being delayed.
+  // powerd-supplied ID corresponding to an imminent (either regular or dark)
+  // suspend attempt that is currently being delayed.
   int32_t pending_suspend_id_;
   bool suspend_is_pending_;
 
   // Set to true when the suspend currently being delayed was triggered during a
   // dark resume.  Since |pending_suspend_id_| and |suspend_is_pending_| are
   // both shared by normal and dark suspends, |suspending_from_dark_resume_|
   // helps distinguish the context within which these variables are being used.
   bool suspending_from_dark_resume_;
 
   // Number of callbacks that have been returned by
@@ skipping 24 matching lines @@
 // static
 PowerManagerClient* PowerManagerClient::Create(
     DBusClientImplementationType type) {
   if (type == REAL_DBUS_CLIENT_IMPLEMENTATION)
     return new PowerManagerClientImpl();
   DCHECK_EQ(STUB_DBUS_CLIENT_IMPLEMENTATION, type);
   return new FakePowerManagerClient();
 }
 
 }  // namespace chromeos