chromeos: Avoid crash on synchronous suspend readiness call.

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 41 matching lines @@
       : origin_thread_id_(base::PlatformThread::CurrentId()),
         power_manager_proxy_(NULL),
         suspend_delay_id_(-1),
         has_suspend_delay_id_(false),
         dark_suspend_delay_id_(-1),
         has_dark_suspend_delay_id_(false),
         pending_suspend_id_(-1),
         suspend_is_pending_(false),
         suspending_from_dark_resume_(false),
         num_pending_suspend_readiness_callbacks_(0),
+        notifying_observers_about_suspend_imminent_(false),
         last_is_projecting_(false),
         weak_ptr_factory_(this) {}
 
   ~PowerManagerClientImpl() override {
     // Here we should unregister suspend notifications from powerd,
     // however:
     // - The lifetime of the PowerManagerClientImpl can extend past that of
     //   the objectproxy,
     // - power_manager can already detect that the client is gone and
     //   unregister our suspend delay.
@@ skipping 465 matching lines @@
                        << 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;
 
+    // Record the fact that observers are being notified to ensure that we don't
+    // report readiness prematurely if one of them calls
+    // GetSuspendReadinessCallback() and then runs the callback synchonously
+    // instead of asynchronously.
+    notifying_observers_about_suspend_imminent_ = true;
     if (suspending_from_dark_resume_)
       FOR_EACH_OBSERVER(Observer, observers_, DarkSuspendImminent());
     else
       FOR_EACH_OBSERVER(Observer, observers_, SuspendImminent());
+    notifying_observers_about_suspend_imminent_ = false;
+
     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";
@@ skipping 160 matching lines @@
 
     num_pending_suspend_readiness_callbacks_--;
     MaybeReportSuspendReadiness();
   }
 
   // Reports suspend readiness to powerd if no observers are still holding
   // suspend readiness callbacks.
   void MaybeReportSuspendReadiness() {
     CHECK(suspend_is_pending_);
 
+    // Avoid reporting suspend readiness if some observers have yet to be
+    // notified about the pending attempt.
+    if (notifying_observers_about_suspend_imminent_)
+      return;
+
     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;
@@ skipping 49 matching lines @@
   // 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
   // GetSuspendReadinessCallback() during the currently-pending suspend
   // attempt but have not yet been called.
   int num_pending_suspend_readiness_callbacks_;
 
+  // Inspected by MaybeReportSuspendReadiness() to avoid prematurely notifying
+  // powerd about suspend readiness while |observers_|' SuspendImminent()
+  // methods are being called by HandleSuspendImminent().
+  bool notifying_observers_about_suspend_imminent_;
+
   // Last state passed to SetIsProjecting().
   bool last_is_projecting_;
 
   // The delegate used to manage the power consumption of Chrome's renderer
   // processes.
   base::WeakPtr<RenderProcessManagerDelegate> render_process_manager_delegate_;
 
   // Note: This should remain the last member so it'll be destroyed and
   // invalidate its weak pointers before any other members are destroyed.
   base::WeakPtrFactory<PowerManagerClientImpl> weak_ptr_factory_;
@@ skipping 10 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