Generalize network_event_log -> device_event_log

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"
 #include "base/command_line.h"
 #include "base/format_macros.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "base/observer_list.h"
 #include "base/power_monitor/power_monitor_device_source.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_split.h"
 #include "base/strings/stringprintf.h"
 #include "base/threading/platform_thread.h"
 #include "base/time/time.h"
 #include "base/timer/timer.h"
 #include "chromeos/chromeos_switches.h"
 #include "chromeos/dbus/power_manager/input_event.pb.h"
 #include "chromeos/dbus/power_manager/peripheral_battery_status.pb.h"
 #include "chromeos/dbus/power_manager/policy.pb.h"
 #include "chromeos/dbus/power_manager/power_supply_properties.pb.h"
 #include "chromeos/dbus/power_manager/suspend.pb.h"
+#include "chromeos/device_event_log.h"
 #include "dbus/bus.h"
 #include "dbus/message.h"
 #include "dbus/object_path.h"
 #include "dbus/object_proxy.h"
 
 namespace chromeos {
 
 // Maximum amount of time that the power manager will wait for Chrome to
 // say that it's ready for the system to be suspended, in milliseconds.
 const int kSuspendDelayTimeoutMs = 5000;
@@ skipping 99 matching lines @@
         power_manager::kPowerManagerInterface,
         power_manager::kGetScreenBrightnessPercentMethod);
     power_manager_proxy_->CallMethod(
         &method_call,
         dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
         base::Bind(&PowerManagerClientImpl::OnGetScreenBrightnessPercent,
                    weak_ptr_factory_.GetWeakPtr(), callback));
   }
 
   virtual void RequestStatusUpdate() override {
+    POWER_LOG(USER) << "RequestStatusUpdate";
     dbus::MethodCall method_call(
         power_manager::kPowerManagerInterface,
         power_manager::kGetPowerSupplyPropertiesMethod);
     power_manager_proxy_->CallMethod(
         &method_call,
         dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
         base::Bind(&PowerManagerClientImpl::OnGetPowerSupplyPropertiesMethod,
                    weak_ptr_factory_.GetWeakPtr()));
   }
 
   virtual void RequestSuspend() override {
+    POWER_LOG(USER) << "RequestSuspend";
     SimpleMethodCallToPowerManager(power_manager::kRequestSuspendMethod);
   }
 
   virtual void RequestRestart() override {
+    POWER_LOG(USER) << "RequestRestart";
     SimpleMethodCallToPowerManager(power_manager::kRequestRestartMethod);
   }
 
   virtual void RequestShutdown() override {
+    POWER_LOG(USER) << "RequestShutdown";
     SimpleMethodCallToPowerManager(power_manager::kRequestShutdownMethod);
   }
 
   virtual void NotifyUserActivity(
       power_manager::UserActivityType type) override {
     dbus::MethodCall method_call(
         power_manager::kPowerManagerInterface,
         power_manager::kHandleUserActivityMethod);
     dbus::MessageWriter writer(&method_call);
     writer.AppendInt32(type);
@@ skipping 12 matching lines @@
     writer.AppendBool(is_fullscreen);
 
     power_manager_proxy_->CallMethod(
         &method_call,
         dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
         dbus::ObjectProxy::EmptyResponseCallback());
   }
 
   virtual void SetPolicy(
       const power_manager::PowerManagementPolicy& policy) override {
+    POWER_LOG(USER) << "SetPolicy";
     dbus::MethodCall method_call(
         power_manager::kPowerManagerInterface,
         power_manager::kSetPolicyMethod);
     dbus::MessageWriter writer(&method_call);
     if (!writer.AppendProtoAsArrayOfBytes(policy)) {
-      LOG(ERROR) << "Error calling " << power_manager::kSetPolicyMethod;
+      POWER_LOG(ERROR) << "Error calling " << power_manager::kSetPolicyMethod;
       return;
     }
     power_manager_proxy_->CallMethod(
         &method_call,
         dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
         dbus::ObjectProxy::EmptyResponseCallback());
   }
 
   virtual void SetIsProjecting(bool is_projecting) override {
+    POWER_LOG(USER) << "SetIsProjecting";
     dbus::MethodCall method_call(
         power_manager::kPowerManagerInterface,
         power_manager::kSetIsProjectingMethod);
     dbus::MessageWriter writer(&method_call);
     writer.AppendBool(is_projecting);
     power_manager_proxy_->CallMethod(
         &method_call,
         dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
         dbus::ObjectProxy::EmptyResponseCallback());
     last_is_projecting_ = is_projecting;
@@ skipping 107 matching lines @@
  private:
   // Returns true if the current thread is the origin thread.
   bool OnOriginThread() {
     return base::PlatformThread::CurrentId() == origin_thread_id_;
   }
 
   // Called when a dbus signal is initially connected.
   void SignalConnected(const std::string& interface_name,
                        const std::string& signal_name,
                        bool success) {
-    LOG_IF(WARNING, !success) << "Failed to connect to signal "
-                              << signal_name << ".";
+    if (!success)
+      POWER_LOG(ERROR) << "Failed to connect to signal " << signal_name << ".";
   }
 
   // Makes a method call to power manager with no arguments and no response.
   void SimpleMethodCallToPowerManager(const std::string& method_name) {
     dbus::MethodCall method_call(power_manager::kPowerManagerInterface,
                                  method_name);
     power_manager_proxy_->CallMethod(
         &method_call,
         dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
         dbus::ObjectProxy::EmptyResponseCallback());
   }
 
   void NameOwnerChangedReceived(const std::string& old_owner,
                                 const std::string& new_owner) {
-    VLOG(1) << "Power manager restarted (old owner was "
-            << (old_owner.empty() ? "[none]" : old_owner.c_str())
-            << ", new owner is "
-            << (new_owner.empty() ? "[none]" : new_owner.c_str()) << ")";
+    POWER_LOG(EVENT) << "Power manager restarted. Old owner: "
+                     << (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()) {
-      VLOG(1) << "Sending initial state to power manager";
+      POWER_LOG(EVENT) << "Sending initial state to power manager";
       RegisterSuspendDelays();
       SetIsProjecting(last_is_projecting_);
       FOR_EACH_OBSERVER(Observer, observers_, 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))) {
-      LOG(ERROR) << "Brightness changed signal had incorrect parameters: "
-                 << signal->ToString();
+      POWER_LOG(ERROR) << "Brightness changed signal had incorrect parameters: "
+                       << signal->ToString();
       return;
     }
-    VLOG(1) << "Brightness changed to " << brightness_level
-            << ": user initiated " << user_initiated;
+    POWER_LOG(DEBUG) << "Brightness changed to " << brightness_level
+                     << ": user initiated " << user_initiated;
     FOR_EACH_OBSERVER(Observer, observers_,
                       BrightnessChanged(brightness_level, user_initiated));
   }
 
   void PeripheralBatteryStatusReceived(dbus::Signal* signal) {
     dbus::MessageReader reader(signal);
     power_manager::PeripheralBatteryStatus protobuf_status;
     if (!reader.PopArrayOfBytesAsProto(&protobuf_status)) {
-      LOG(ERROR) << "Unable to decode protocol buffer from "
-                 << power_manager::kPeripheralBatteryStatusSignal << " signal";
+      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;
 
-    VLOG(1) << "Device battery status received " << level
-            << " for " << name << " at " << path;
+    POWER_LOG(DEBUG) << "Device battery status received " << level << " for "
+                     << name << " at " << path;
 
     FOR_EACH_OBSERVER(Observer, observers_,
                       PeripheralBatteryStatusReceived(path, name, level));
   }
 
   void PowerSupplyPollReceived(dbus::Signal* signal) {
-    VLOG(1) << "Received power supply poll signal.";
+    POWER_LOG(DEBUG) << "Received power supply poll signal.";
     dbus::MessageReader reader(signal);
     power_manager::PowerSupplyProperties protobuf;
     if (reader.PopArrayOfBytesAsProto(&protobuf)) {
       HandlePowerSupplyProperties(protobuf);
     } else {
-      LOG(ERROR) << "Unable to decode "
-                 << power_manager::kPowerSupplyPollSignal << "signal";
+      POWER_LOG(ERROR) << "Unable to decode "
+                       << power_manager::kPowerSupplyPollSignal << " signal";
     }
   }
 
   void OnGetPowerSupplyPropertiesMethod(dbus::Response* response) {
     if (!response) {
-      LOG(ERROR) << "Error calling "
-                 << power_manager::kGetPowerSupplyPropertiesMethod;
+      POWER_LOG(ERROR) << "Error calling "
+                       << power_manager::kGetPowerSupplyPropertiesMethod;
       return;
     }
 
     dbus::MessageReader reader(response);
     power_manager::PowerSupplyProperties protobuf;
     if (reader.PopArrayOfBytesAsProto(&protobuf)) {
       HandlePowerSupplyProperties(protobuf);
     } else {
-      LOG(ERROR) << "Unable to decode "
-                 << power_manager::kGetPowerSupplyPropertiesMethod
-                 << " response";
+      POWER_LOG(ERROR) << "Unable to decode "
+                       << power_manager::kGetPowerSupplyPropertiesMethod
+                       << " response";
     }
   }
 
   void OnGetScreenBrightnessPercent(
       const GetScreenBrightnessPercentCallback& callback,
       dbus::Response* response) {
     if (!response) {
-      LOG(ERROR) << "Error calling "
-                 << power_manager::kGetScreenBrightnessPercentMethod;
+      POWER_LOG(ERROR) << "Error calling "
+                       << power_manager::kGetScreenBrightnessPercentMethod;
       return;
     }
     dbus::MessageReader reader(response);
     double percent = 0.0;
     if (!reader.PopDouble(&percent))
-      LOG(ERROR) << "Error reading response from powerd: "
-                 << response->ToString();
+      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));
     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) {
-      LOG(ERROR) << "Error calling " << method_name;
+      POWER_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 " << method_name;
+      POWER_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_;
+      POWER_LOG(EVENT) << "Registered dark suspend delay "
+                       << dark_suspend_delay_id_;
     } else {
       suspend_delay_id_ = protobuf.delay_id();
       has_suspend_delay_id_ = true;
-      VLOG(1) << "Registered suspend delay " << suspend_delay_id_;
+      POWER_LOG(EVENT) << "Registered suspend delay " << suspend_delay_id_;
     }
   }
 
   void HandleSuspendImminent(bool in_dark_resume, dbus::Signal* signal) {
     std::string signal_name = signal->GetMember();
     if ((in_dark_resume && !has_dark_suspend_delay_id_) ||
         (!in_dark_resume && !has_suspend_delay_id_)) {
-      LOG(ERROR) << "Received unrequested " << signal_name << " signal";
+      POWER_LOG(ERROR) << "Received unrequested " << signal_name << " signal";
       return;
     }
 
     dbus::MessageReader reader(signal);
     power_manager::SuspendImminent proto;
     if (!reader.PopArrayOfBytesAsProto(&proto)) {
-      LOG(ERROR) << "Unable to decode protocol buffer from " << signal_name
-                 << " signal";
+      POWER_LOG(ERROR) << "Unable to decode protocol buffer from "
+                       << signal_name << " signal";
       return;
     }
 
-    VLOG(1) << "Got " << signal_name << " signal announcing suspend attempt "
-            << proto.suspend_id();
+    POWER_LOG(EVENT) << "Got " << signal_name
+                     << " signal announcing suspend attempt "
+                     << proto.suspend_id();
 
     // If a previous suspend is pending from the same state we are currently in
     // (fully powered on or in dark resume), then something's gone a little
     // wonky.
-    if (suspend_is_pending_ &&
-        suspending_from_dark_resume_ == in_dark_resume) {
-      LOG(WARNING) << "Got " << signal_name << " signal about pending suspend "
-                   << "attempt " << proto.suspend_id() << " while still "
-                   << "waiting on attempt " << pending_suspend_id_;
+    if (suspend_is_pending_ && suspending_from_dark_resume_ == in_dark_resume) {
+      POWER_LOG(ERROR) << "Got " << signal_name
+                       << " 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)) {
-      LOG(ERROR) << "Unable to decode protocol buffer from "
-                 << power_manager::kSuspendDoneSignal << " signal";
+      POWER_LOG(ERROR) << "Unable to decode protocol buffer from "
+                       << power_manager::kSuspendDoneSignal << " signal";
       return;
     }
 
     const base::TimeDelta duration =
         base::TimeDelta::FromInternalValue(proto.suspend_duration());
-    VLOG(1) << "Got " << power_manager::kSuspendDoneSignal << " signal:"
-            << " suspend_id=" << proto.suspend_id()
-            << " duration=" << duration.InSeconds() << " sec";
+    POWER_LOG(EVENT) << "Got " << power_manager::kSuspendDoneSignal
+                     << " signal:"
+                     << " suspend_id=" << proto.suspend_id()
+                     << " duration=" << duration.InSeconds() << " sec";
 
     if (render_process_manager_delegate_)
       render_process_manager_delegate_->SuspendDone();
 
     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)) {
-      LOG(ERROR) << "Unable to decode protocol buffer from "
-                 << power_manager::kIdleActionImminentSignal << " signal";
+      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())));
   }
 
   void IdleActionDeferredReceived(dbus::Signal* signal) {
     FOR_EACH_OBSERVER(Observer, observers_, IdleActionDeferred());
   }
 
   void InputEventReceived(dbus::Signal* signal) {
     dbus::MessageReader reader(signal);
     power_manager::InputEvent proto;
     if (!reader.PopArrayOfBytesAsProto(&proto)) {
-      LOG(ERROR) << "Unable to decode protocol buffer from "
-                 << power_manager::kInputEventSignal << " signal";
+      POWER_LOG(ERROR) << "Unable to decode protocol buffer from "
+                       << power_manager::kInputEventSignal << " signal";
       return;
     }
 
     base::TimeTicks timestamp =
         base::TimeTicks::FromInternalValue(proto.timestamp());
-    VLOG(1) << "Got " << power_manager::kInputEventSignal << " signal:"
-            << " type=" << proto.type() << " timestamp=" << 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));
 
         // Tell powerd that Chrome has handled power button presses.
         if (down) {
@@ skipping 22 matching lines @@
 
   void RegisterSuspendDelayImpl(
       const std::string& method_name,
       const power_manager::RegisterSuspendDelayRequest& protobuf_request,
       dbus::ObjectProxy::ResponseCallback callback) {
     dbus::MethodCall method_call(
         power_manager::kPowerManagerInterface, method_name);
     dbus::MessageWriter writer(&method_call);
 
     if (!writer.AppendProtoAsArrayOfBytes(protobuf_request)) {
-      LOG(ERROR) << "Error constructing message for " << method_name;
+      POWER_LOG(ERROR) << "Error constructing message for " << method_name;
       return;
     }
 
     power_manager_proxy_->CallMethod(
         &method_call, dbus::ObjectProxy::TIMEOUT_USE_DEFAULT, callback);
   }
 
   // Registers suspend delays with the power manager.  This is usually only
   // called at startup, but if the power manager restarts, we need to create new
   // delays.
@@ skipping 54 matching lines @@
       delay_id = suspend_delay_id_;
     }
 
     if (render_process_manager_delegate_ && !suspending_from_dark_resume_)
       render_process_manager_delegate_->SuspendImminent();
 
     dbus::MethodCall method_call(
         power_manager::kPowerManagerInterface, method_name);
     dbus::MessageWriter writer(&method_call);
 
-    VLOG(1) << "Announcing readiness of suspend delay " << delay_id
-            << " for suspend attempt " << pending_suspend_id_;
+    POWER_LOG(EVENT) << "Announcing readiness of suspend delay " << delay_id
+                     << " for suspend attempt " << pending_suspend_id_;
     power_manager::SuspendReadinessInfo protobuf_request;
     protobuf_request.set_delay_id(delay_id);
     protobuf_request.set_suspend_id(pending_suspend_id_);
 
     pending_suspend_id_ = -1;
     suspend_is_pending_ = false;
 
     if (!writer.AppendProtoAsArrayOfBytes(protobuf_request)) {
-      LOG(ERROR) << "Error constructing message for " << method_name;
+      POWER_LOG(ERROR) << "Error constructing message for " << method_name;
       return;
     }
     power_manager_proxy_->CallMethod(
         &method_call,
         dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
         dbus::ObjectProxy::EmptyResponseCallback());
   }
 
   // Origin thread (i.e. the UI thread in production).
   base::PlatformThreadId origin_thread_id_;
@@ skipping 79 matching lines @@
 
   virtual bool HasObserver(const Observer* observer) const override {
     return observers_.HasObserver(observer);
   }
 
   virtual void SetRenderProcessManagerDelegate(
       base::WeakPtr<RenderProcessManagerDelegate> delegate) override {
   }
 
   virtual void DecreaseScreenBrightness(bool allow_off) override {
-    VLOG(1) << "Requested to descrease screen brightness";
+    POWER_LOG(USER) << "Requested to descrease screen brightness";
     SetBrightness(brightness_ - 5.0, true);
   }
 
   virtual void IncreaseScreenBrightness() override {
-    VLOG(1) << "Requested to increase screen brightness";
+    POWER_LOG(USER) << "Requested to increase screen brightness";
     SetBrightness(brightness_ + 5.0, true);
   }
 
   virtual void SetScreenBrightnessPercent(double percent,
                                           bool gradual) override {
-    VLOG(1) << "Requested to set screen brightness to " << percent << "% "
-            << (gradual ? "gradually" : "instantaneously");
+    POWER_LOG(USER) << "Requested to set screen brightness to " << percent
+                    << "% " << (gradual ? "gradually" : "instantaneously");
     SetBrightness(percent, false);
   }
 
   virtual void GetScreenBrightnessPercent(
       const GetScreenBrightnessPercentCallback& callback) override {
+    POWER_LOG(USER) << "Requested to get screen brightness";
     callback.Run(brightness_);
   }
 
   virtual void DecreaseKeyboardBrightness() override {
-    VLOG(1) << "Requested to descrease keyboard brightness";
+    POWER_LOG(USER) << "Requested to descrease keyboard brightness";
   }
 
   virtual void IncreaseKeyboardBrightness() override {
-    VLOG(1) << "Requested to increase keyboard brightness";
+    POWER_LOG(USER) << "Requested to increase keyboard brightness";
   }
 
   virtual void RequestStatusUpdate() override {
-    base::MessageLoop::current()->PostTask(FROM_HERE,
-        base::Bind(&PowerManagerClientStubImpl::UpdateStatus,
-                   weak_ptr_factory_.GetWeakPtr()));
+    POWER_LOG(USER) << "Requested status update";
+    base::MessageLoop::current()->PostTask(
+        FROM_HERE, base::Bind(&PowerManagerClientStubImpl::UpdateStatus,
+                              weak_ptr_factory_.GetWeakPtr()));
   }
 
   virtual void RequestSuspend() override {}
   virtual void RequestRestart() override {}
   virtual void RequestShutdown() override {}
 
   virtual void NotifyUserActivity(
       power_manager::UserActivityType type) override {}
   virtual void NotifyVideoActivity(bool is_fullscreen) override {}
   virtual void SetPolicy(
@@ skipping 139 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