Replace FOR_EACH_OBSERVER in chromeos/ with range-based for

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 370 matching lines @@
                      << (old_owner.empty() ? "[none]" : old_owner.c_str())
                      << " New owner: "
                      << (new_owner.empty() ? "[none]" : new_owner.c_str());
     suspend_is_pending_ = false;
     pending_suspend_id_ = -1;
     suspending_from_dark_resume_ = false;
     if (!new_owner.empty()) {
       POWER_LOG(EVENT) << "Sending initial state to power manager";
       RegisterSuspendDelays();
       SetIsProjecting(last_is_projecting_);
-      FOR_EACH_OBSERVER(Observer, observers_, PowerManagerRestarted());
+      for (auto& observer : observers_)
+        observer.PowerManagerRestarted();
     }
   }
 
   void BrightnessChangedReceived(dbus::Signal* signal) {
     dbus::MessageReader reader(signal);
     int32_t brightness_level = 0;
     bool user_initiated = 0;
     if (!(reader.PopInt32(&brightness_level) &&
           reader.PopBool(&user_initiated))) {
       POWER_LOG(ERROR) << "Brightness changed signal had incorrect parameters: "
                        << signal->ToString();
       return;
     }
     POWER_LOG(DEBUG) << "Brightness changed to " << brightness_level
                      << ": user initiated " << user_initiated;
-    FOR_EACH_OBSERVER(Observer, observers_,
-                      BrightnessChanged(brightness_level, user_initiated));
+    for (auto& observer : observers_)
+      observer.BrightnessChanged(brightness_level, user_initiated);
   }
 
   void PeripheralBatteryStatusReceived(dbus::Signal* signal) {
     dbus::MessageReader reader(signal);
     power_manager::PeripheralBatteryStatus protobuf_status;
     if (!reader.PopArrayOfBytesAsProto(&protobuf_status)) {
       POWER_LOG(ERROR) << "Unable to decode protocol buffer from "
                        << power_manager::kPeripheralBatteryStatusSignal
                        << " signal";
       return;
     }
 
     std::string path = protobuf_status.path();
     std::string name = protobuf_status.name();
     int level = protobuf_status.has_level() ? protobuf_status.level() : -1;
 
     POWER_LOG(DEBUG) << "Device battery status received " << level << " for "
                      << name << " at " << path;
 
-    FOR_EACH_OBSERVER(Observer, observers_,
-                      PeripheralBatteryStatusReceived(path, name, level));
+    for (auto& observer : observers_)
+      observer.PeripheralBatteryStatusReceived(path, name, level);
   }
 
   void PowerSupplyPollReceived(dbus::Signal* signal) {
     POWER_LOG(DEBUG) << "Received power supply poll signal.";
     dbus::MessageReader reader(signal);
     power_manager::PowerSupplyProperties protobuf;
     if (reader.PopArrayOfBytesAsProto(&protobuf)) {
       HandlePowerSupplyProperties(protobuf);
     } else {
       POWER_LOG(ERROR) << "Unable to decode "
@@ skipping 32 matching lines @@
     dbus::MessageReader reader(response);
     double percent = 0.0;
     if (!reader.PopDouble(&percent))
       POWER_LOG(ERROR) << "Error reading response from powerd: "
                        << response->ToString();
     callback.Run(percent);
   }
 
   void HandlePowerSupplyProperties(
       const power_manager::PowerSupplyProperties& proto) {
-    FOR_EACH_OBSERVER(Observer, observers_, PowerChanged(proto));
+    for (auto& observer : observers_)
+      observer.PowerChanged(proto);
     const bool on_battery = proto.external_power() ==
         power_manager::PowerSupplyProperties_ExternalPower_DISCONNECTED;
     base::PowerMonitorDeviceSource::SetPowerSource(on_battery);
   }
 
   void HandleRegisterSuspendDelayReply(bool dark_suspend,
                                        const std::string& method_name,
                                        dbus::Response* response) {
     if (!response) {
       POWER_LOG(ERROR) << "Error calling " << method_name;
@@ skipping 55 matching lines @@
     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());
+      for (auto& observer : observers_)
+        observer.DarkSuspendImminent();
     else
-      FOR_EACH_OBSERVER(Observer, observers_, SuspendImminent());
+      for (auto& observer : observers_)
+        observer.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)) {
@@ skipping 31 matching lines @@
     }
 
     // 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));
+    for (auto& observer : observers_)
+      observer.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 "
                        << power_manager::kIdleActionImminentSignal << " signal";
       return;
     }
-    FOR_EACH_OBSERVER(Observer, observers_,
-        IdleActionImminent(base::TimeDelta::FromInternalValue(
-            proto.time_until_idle_action())));
+    for (auto& observer : observers_) {
+      observer.IdleActionImminent(
+          base::TimeDelta::FromInternalValue(proto.time_until_idle_action()));
+    }
   }
 
   void IdleActionDeferredReceived(dbus::Signal* signal) {
-    FOR_EACH_OBSERVER(Observer, observers_, IdleActionDeferred());
+    for (auto& observer : observers_)
+      observer.IdleActionDeferred();
   }
 
   void InputEventReceived(dbus::Signal* signal) {
     dbus::MessageReader reader(signal);
     power_manager::InputEvent proto;
     if (!reader.PopArrayOfBytesAsProto(&proto)) {
       POWER_LOG(ERROR) << "Unable to decode protocol buffer from "
                        << power_manager::kInputEventSignal << " signal";
       return;
     }
 
     base::TimeTicks timestamp =
         base::TimeTicks::FromInternalValue(proto.timestamp());
     POWER_LOG(USER) << "Got " << power_manager::kInputEventSignal << " signal:"
                     << " type=" << proto.type()
                     << " timestamp=" << proto.timestamp();
     switch (proto.type()) {
       case power_manager::InputEvent_Type_POWER_BUTTON_DOWN:
       case power_manager::InputEvent_Type_POWER_BUTTON_UP: {
         const bool down =
             (proto.type() == power_manager::InputEvent_Type_POWER_BUTTON_DOWN);
-        FOR_EACH_OBSERVER(PowerManagerClient::Observer, observers_,
-                          PowerButtonEventReceived(down, timestamp));
+        for (auto& observer : observers_)
+          observer.PowerButtonEventReceived(down, timestamp);
 
         // Tell powerd that Chrome has handled power button presses.
         if (down) {
           dbus::MethodCall method_call(
               power_manager::kPowerManagerInterface,
               power_manager::kHandlePowerButtonAcknowledgmentMethod);
           dbus::MessageWriter writer(&method_call);
           writer.AppendInt64(proto.timestamp());
           power_manager_proxy_->CallMethod(
               &method_call,
               dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
               dbus::ObjectProxy::EmptyResponseCallback());
         }
         break;
       }
       case power_manager::InputEvent_Type_LID_OPEN:
       case power_manager::InputEvent_Type_LID_CLOSED: {
         bool open =
             (proto.type() == power_manager::InputEvent_Type_LID_OPEN);
-        FOR_EACH_OBSERVER(PowerManagerClient::Observer, observers_,
-                          LidEventReceived(open, timestamp));
+        for (auto& observer : observers_)
+          observer.LidEventReceived(open, timestamp);
         break;
       }
       case power_manager::InputEvent_Type_TABLET_MODE_ON:
       case power_manager::InputEvent_Type_TABLET_MODE_OFF: {
         bool on =
             (proto.type() == power_manager::InputEvent_Type_TABLET_MODE_ON);
-        FOR_EACH_OBSERVER(PowerManagerClient::Observer, observers_,
-                          TabletModeEventReceived(on, timestamp));
+        for (auto& observer : observers_)
+          observer.TabletModeEventReceived(on, timestamp);
         break;
       }
     }
   }
 
   void RegisterSuspendDelayImpl(
       const std::string& method_name,
       const power_manager::RegisterSuspendDelayRequest& protobuf_request,
       dbus::ObjectProxy::ResponseCallback callback) {
     dbus::MethodCall method_call(
@@ skipping 180 matching lines @@
 // static
 PowerManagerClient* PowerManagerClient::Create(
     DBusClientImplementationType type) {
   if (type == REAL_DBUS_CLIENT_IMPLEMENTATION)
     return new PowerManagerClientImpl();
   DCHECK_EQ(FAKE_DBUS_CLIENT_IMPLEMENTATION, type);
   return new FakePowerManagerClient();
 }
 
 }  // namespace chromeos