Generalize network_event_log -> device_event_log

chromeos/network/network_state_handler.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/network/network_state_handler.h"
 
 #include "base/bind.h"
 #include "base/format_macros.h"
 #include "base/guid.h"
+#include "base/json/json_string_value_serializer.h"
+#include "base/json/json_writer.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/metrics/histogram.h"
 #include "base/stl_util.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/values.h"
 #include "chromeos/network/device_state.h"
 #include "chromeos/network/managed_state.h"
 #include "chromeos/network/network_event_log.h"
@@ skipping 24 matching lines @@
   return "";
 }
 
 std::string GetLogName(const ManagedState* state) {
   if (!state)
     return "None";
   return base::StringPrintf("%s (%s)", state->name().c_str(),
                             state->path().c_str());
 }
 
+std::string ValueAsString(const base::Value& value) {
+  std::string vstr;
+  base::JSONWriter::WriteWithOptions(
+      &value, base::JSONWriter::OPTIONS_OMIT_BINARY_VALUES, &vstr);
+  return vstr.empty() ? "''" : vstr;
+}
+
 }  // namespace
 
 const char NetworkStateHandler::kDefaultCheckPortalList[] =
     "ethernet,wifi,cellular";
 
 NetworkStateHandler::NetworkStateHandler()
     : network_list_sorted_(false) {
 }
 
 NetworkStateHandler::~NetworkStateHandler() {
@@ skipping 11 matching lines @@
 NetworkStateHandler* NetworkStateHandler::InitializeForTest() {
   NetworkStateHandler* handler = new NetworkStateHandler();
   handler->InitShillPropertyHandler();
   return handler;
 }
 
 void NetworkStateHandler::AddObserver(
     NetworkStateHandlerObserver* observer,
     const tracked_objects::Location& from_here) {
   observers_.AddObserver(observer);
-  network_event_log::internal::AddEntry(
+  device_event_log::AddEntry(
       from_here.file_name(), from_here.line_number(),
-      network_event_log::LOG_LEVEL_DEBUG,
-      "NetworkStateHandler::AddObserver", "");
+      device_event_log::LOG_TYPE_NETWORK,
+      device_event_log::LOG_LEVEL_DEBUG,
+      "NetworkStateHandler::AddObserver");
 }
 
 void NetworkStateHandler::RemoveObserver(
     NetworkStateHandlerObserver* observer,
     const tracked_objects::Location& from_here) {
   observers_.RemoveObserver(observer);
-  network_event_log::internal::AddEntry(
+  device_event_log::AddEntry(
       from_here.file_name(), from_here.line_number(),
-      network_event_log::LOG_LEVEL_DEBUG,
-      "NetworkStateHandler::RemoveObserver", "");
+      device_event_log::LOG_TYPE_NETWORK,
+      device_event_log::LOG_LEVEL_DEBUG,
+      "NetworkStateHandler::RemoveObserver");
 }
 
 NetworkStateHandler::TechnologyState NetworkStateHandler::GetTechnologyState(
     const NetworkTypePattern& type) const {
   std::string technology = GetTechnologyForType(type);
   TechnologyState state;
   if (shill_property_handler_->IsTechnologyEnabled(technology))
     state = TECHNOLOGY_ENABLED;
   else if (shill_property_handler_->IsTechnologyEnabling(technology))
     state = TECHNOLOGY_ENABLING;
@@ skipping 453 matching lines @@
         key != shill::kWifiFrequencyListProperty &&
         (key != shill::kDeviceProperty || value_str != "/")) {
       std::string log_event = "NetworkPropertyUpdated";
       // Trigger a default network update for interesting changes only.
       if (network->path() == default_network_path_) {
         NotifyDefaultNetworkChanged(network);
         log_event = "Default" + log_event;
       }
       // Log event.
       std::string detail = network->name() + "." + key;
-      detail += " = " + network_event_log::ValueAsString(value);
-      network_event_log::LogLevel log_level;
+      detail += " = " + ValueAsString(value);
+      device_event_log::LogLevel log_level;
       if (key == shill::kErrorProperty || key == shill::kErrorDetailsProperty) {
-        log_level = network_event_log::LOG_LEVEL_ERROR;
+        log_level = device_event_log::LOG_LEVEL_ERROR;
       } else {
-        log_level = network_event_log::LOG_LEVEL_EVENT;
+        log_level = device_event_log::LOG_LEVEL_EVENT;
       }
       NET_LOG_LEVEL(log_level, log_event, detail);
     }
   }
 
   // All property updates signal 'NetworkPropertiesUpdated'.
   NotifyNetworkPropertiesUpdated(network);
 
   // If added to a Profile, request a full update so that a NetworkState
   // gets created.
   if (prev_profile_path.empty() && !network->profile_path().empty())
     RequestUpdateForNetwork(service_path);
 }
 
 void NetworkStateHandler::UpdateDeviceProperty(const std::string& device_path,
                                                const std::string& key,
                                                const base::Value& value) {
   DeviceState* device = GetModifiableDeviceState(device_path);
   if (!device)
     return;
   if (!device->PropertyChanged(key, value))
     return;
 
   std::string detail = device->name() + "." + key;
-  detail += " = " + network_event_log::ValueAsString(value);
+  detail += " = " + ValueAsString(value);
   NET_LOG_EVENT("DevicePropertyUpdated", detail);
 
   NotifyDeviceListChanged();
   NotifyDevicePropertiesUpdated(device);
 
   if (key == shill::kScanningProperty && device->scanning() == false) {
     NotifyScanCompleted(device);
   }
   if (key == shill::kEapAuthenticationCompletedProperty) {
     // Notify a change for each Ethernet service using this device.
@@ skipping 330 matching lines @@
   if (type.MatchesType(shill::kTypeBluetooth))
     technologies.push_back(new std::string(shill::kTypeBluetooth));
   if (type.MatchesType(shill::kTypeVPN))
     technologies.push_back(new std::string(shill::kTypeVPN));
 
   CHECK_GT(technologies.size(), 0ul);
   return technologies.Pass();
 }
 
 }  // namespace chromeos