chromeos: Avoid a startup crash when powerd isn't running.

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 <algorithm>
 
 #include "base/bind.h"
 #include "base/callback.h"
@@ skipping 420 matching lines @@
     }
     dbus::MessageReader reader(response);
     double percent = 0.0;
     if (!reader.PopDouble(&percent))
       LOG(ERROR) << "Error reading response from powerd: "
                  << response->ToString();
     callback.Run(percent);
   }
 
   void HandleRegisterSuspendDelayReply(bool dark_suspend,
+                                       const std::string& method_name,
                                        dbus::Response* response) {
     if (!response) {
-      LOG(ERROR) << "Error calling " << response->GetMember();
+      LOG(ERROR) << "Error calling " << method_name;
       return;
     }
 
     dbus::MessageReader reader(response);
     power_manager::RegisterSuspendDelayReply protobuf;
     if (!reader.PopArrayOfBytesAsProto(&protobuf)) {
-      LOG(ERROR) << "Unable to parse reply from " << response->GetMember();
+      LOG(ERROR) << "Unable to parse reply from " << method_name;
       return;
     }
 
     if (dark_suspend) {
       dark_suspend_delay_id_ = protobuf.delay_id();
       has_dark_suspend_delay_id_ = true;
       VLOG(1) << "Registered dark suspend delay " << dark_suspend_delay_id_;
     } else {
       suspend_delay_id_ = protobuf.delay_id();
       has_suspend_delay_id_ = true;
@@ skipping 151 matching lines @@
 
     power_manager::RegisterSuspendDelayRequest protobuf_request;
     base::TimeDelta timeout =
         base::TimeDelta::FromMilliseconds(kSuspendDelayTimeoutMs);
     protobuf_request.set_timeout(timeout.ToInternalValue());
     protobuf_request.set_description(kSuspendDelayDescription);
 
     RegisterSuspendDelayImpl(
         power_manager::kRegisterSuspendDelayMethod,
         protobuf_request,
-        base::Bind(
-            &PowerManagerClientImpl::HandleRegisterSuspendDelayReply,
-            weak_ptr_factory_.GetWeakPtr(), false));
+        base::Bind(&PowerManagerClientImpl::HandleRegisterSuspendDelayReply,
+                   weak_ptr_factory_.GetWeakPtr(), false,
+                   power_manager::kRegisterSuspendDelayMethod));
     RegisterSuspendDelayImpl(
         power_manager::kRegisterDarkSuspendDelayMethod,
         protobuf_request,
-        base::Bind(
-            &PowerManagerClientImpl::HandleRegisterSuspendDelayReply,
-            weak_ptr_factory_.GetWeakPtr(), true));
+        base::Bind(&PowerManagerClientImpl::HandleRegisterSuspendDelayReply,
+                   weak_ptr_factory_.GetWeakPtr(), true,
+                   power_manager::kRegisterDarkSuspendDelayMethod));
   }
 
   // Records the fact that an observer has finished doing asynchronous work
   // that was blocking a pending suspend attempt and possibly reports
   // suspend readiness to powerd.  Called by callbacks returned via
   // GetSuspendReadinessCallback().
   void HandleObserverSuspendReadiness(int32_t suspend_id, bool in_dark_resume) {
     DCHECK(OnOriginThread());
     if (!suspend_is_pending_ || suspend_id != pending_suspend_id_ ||
         in_dark_resume != suspending_from_dark_resume_)
@@ skipping 309 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 PowerManagerClientStubImpl();
 }
 
 }  // namespace chromeos