chromeos: Avoid crash on synchronous suspend readiness call.

chromeos/dbus/power_manager_client_unittest.cc

 // Copyright 2016 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 <map>
 #include <string>
 
 #include "base/bind.h"
@@ skipping 78 matching lines @@
   int num_suspend_imminent() const { return num_suspend_imminent_; }
   int num_suspend_done() const { return num_suspend_done_; }
   int num_dark_suspend_imminent() const { return num_dark_suspend_imminent_; }
   base::Closure suspend_readiness_callback() const {
     return suspend_readiness_callback_;
   }
 
   void set_take_suspend_readiness_callback(bool take_callback) {
     take_suspend_readiness_callback_ = take_callback;
   }
+  void set_run_suspend_readiness_callback_immediately(bool run) {
+    run_suspend_readiness_callback_immediately_ = run;
+  }
 
   // Runs |suspend_readiness_callback_|.
   bool RunSuspendReadinessCallback() WARN_UNUSED_RESULT {
     if (suspend_readiness_callback_.is_null())
       return false;
 
     auto cb = suspend_readiness_callback_;
     suspend_readiness_callback_.Reset();
     cb.Run();
     return true;
   }
 
   // PowerManagerClient::Observer:
   void SuspendImminent() override {
     num_suspend_imminent_++;
     if (take_suspend_readiness_callback_)
       suspend_readiness_callback_ = client_->GetSuspendReadinessCallback();
+    if (run_suspend_readiness_callback_immediately_)
+      CHECK(RunSuspendReadinessCallback());
   }
   void SuspendDone(const base::TimeDelta& sleep_duration) override {
     num_suspend_done_++;
   }
   void DarkSuspendImminent() override {
     num_dark_suspend_imminent_++;
     if (take_suspend_readiness_callback_)
       suspend_readiness_callback_ = client_->GetSuspendReadinessCallback();
+    if (run_suspend_readiness_callback_immediately_)
+      CHECK(RunSuspendReadinessCallback());
   }
 
  private:
   PowerManagerClient* client_;  // Not owned.
 
   // Number of times SuspendImminent(), SuspendDone(), and DarkSuspendImminent()
   // have been called.
   int num_suspend_imminent_ = 0;
   int num_suspend_done_ = 0;
   int num_dark_suspend_imminent_ = 0;
 
   // Should SuspendImminent() and DarkSuspendImminent() call |client_|'s
   // GetSuspendReadinessCallback() method?
   bool take_suspend_readiness_callback_ = false;
 
+  // Should SuspendImminent() and DarkSuspendImminent() run the suspend
+  // readiness callback synchronously after taking it? Only has an effect if
+  // |take_suspend_readiness_callback_| is true.
+  bool run_suspend_readiness_callback_immediately_ = false;
+
   // Callback returned by |client_|'s GetSuspendReadinessCallback() method.
   base::Closure suspend_readiness_callback_;
 
   DISALLOW_COPY_AND_ASSIGN(TestObserver);
 };
 
 // Stub implementation of PowerManagerClient::RenderProcessManagerDelegate.
 class TestDelegate : public PowerManagerClient::RenderProcessManagerDelegate {
  public:
   explicit TestDelegate(PowerManagerClient* client) : weak_ptr_factory_(this) {
@@ skipping 364 matching lines @@
   base::Closure dark_callback = observer.suspend_readiness_callback();
 
   // Complete the suspend attempt and run both of the earlier callbacks. Neither
   // should result in readiness being reported.
   EmitSuspendDoneSignal(kSuspendId);
   EXPECT_EQ(1, observer.num_suspend_done());
   regular_callback.Run();
   dark_callback.Run();
 }
 
+// Tests that PowerManagerClient handles a single observer that requests a
+// suspend-readiness callback and then runs it synchronously from within
+// SuspendImminent() instead of running it asynchronously:
+// http://crosbug.com/p/58295
+TEST_F(PowerManagerClientTest, SyncCallbackWithSingleObserver) {
+  TestObserver observer(client_.get());
+  observer.set_take_suspend_readiness_callback(true);
+  observer.set_run_suspend_readiness_callback_immediately(true);
+
+  const int kSuspendId = 1;
+  ExpectSuspendReadiness(kHandleSuspendReadiness, kSuspendId, kSuspendDelayId);
+  EmitSuspendImminentSignal(kSuspendImminent, kSuspendId);
+  EmitSuspendDoneSignal(kSuspendId);
+}
+
+// Tests the case where one observer reports suspend readiness by running its
+// callback before a second observer even gets notified about the suspend
+// attempt. We shouldn't report suspend readiness until the second observer has
+// been notified and confirmed readiness.
+TEST_F(PowerManagerClientTest, SyncCallbackWithMultipleObservers) {
+  TestObserver observer1(client_.get());
+  observer1.set_take_suspend_readiness_callback(true);
+  observer1.set_run_suspend_readiness_callback_immediately(true);
+
+  TestObserver observer2(client_.get());
+  observer2.set_take_suspend_readiness_callback(true);
+
+  const int kSuspendId = 1;
+  EmitSuspendImminentSignal(kSuspendImminent, kSuspendId);
+  ExpectSuspendReadiness(kHandleSuspendReadiness, kSuspendId, kSuspendDelayId);
+  EXPECT_TRUE(observer2.RunSuspendReadinessCallback());
+  EmitSuspendDoneSignal(kSuspendId);
+}
+
 }  // namespace chromeos