Cleanup network event logging, add to ManagedNetworkConfigurationHandler

chromeos/network/managed_network_configuration_handler_impl.cc

 // Copyright 2013 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/managed_network_configuration_handler_impl.h"
 
 #include <set>
 #include <vector>
 
 #include "base/bind.h"
@@ skipping 51 matching lines @@
                          const std::string& error_name) {
   std::string error_msg = "ManagedConfig Error: " + error_name;
   NET_LOG_ERROR(error_msg, service_path);
   network_handler::RunErrorCallback(
       error_callback, service_path, error_name, error_msg);
 }
 
 void LogErrorWithDict(const tracked_objects::Location& from_where,
                       const std::string& error_name,
                       scoped_ptr<base::DictionaryValue> error_data) {
-  LOG(ERROR) << from_where.ToString() << ": " << error_name;
+  network_event_log::internal::AddEntry(
+       from_where.file_name(), from_where.line_number(),
+       network_event_log::LOG_LEVEL_ERROR,
+       error_name, "");
 }
 
 const base::DictionaryValue* GetByGUID(const GuidToPolicyMap& policies,
                                        const std::string& guid) {
   GuidToPolicyMap::const_iterator it = policies.find(guid);
   if (it == policies.end())
     return NULL;
   return it->second;
 }
 
@@ skipping 53 matching lines @@
 void ManagedNetworkConfigurationHandlerImpl::GetManagedPropertiesCallback(
     const network_handler::DictionaryResultCallback& callback,
     const network_handler::ErrorCallback& error_callback,
     const std::string& service_path,
     const base::DictionaryValue& shill_properties) {
   std::string profile_path;
   shill_properties.GetStringWithoutPathExpansion(shill::kProfileProperty,
                                                  &profile_path);
   const NetworkProfile* profile =
       network_profile_handler_->GetProfileForPath(profile_path);
-  if (!profile) {
-    LOG(ERROR) << "No or no known profile received for service "
-            << service_path << ".";
-  }
+  if (!profile)
+    NET_LOG_ERROR("No profile for service: " + profile_path, service_path);
 
   scoped_ptr<NetworkUIData> ui_data =
       shill_property_util::GetUIDataFromProperties(shill_properties);
 
   const base::DictionaryValue* user_settings = NULL;
   const base::DictionaryValue* shared_settings = NULL;
 
   if (ui_data && profile) {
     if (profile->type() == NetworkProfile::TYPE_SHARED)
       shared_settings = ui_data->user_settings();
     else if (profile->type() == NetworkProfile::TYPE_USER)
       user_settings = ui_data->user_settings();
     else
       NOTREACHED();
   } else if (profile) {
-    LOG(WARNING) << "Service " << service_path << " of profile "
-                 << profile_path << " contains no or no valid UIData.";
+    NET_LOG_ERROR("Service contains empty or invalid UIData", service_path);
     // TODO(pneubeck): add a conversion of user configured entries of old
     // ChromeOS versions. We will have to use a heuristic to determine which
     // properties _might_ be user configured.
   }
 
   scoped_ptr<base::DictionaryValue> active_settings(
       onc::TranslateShillServiceToONCPart(
           shill_properties,
           &onc::kNetworkWithStateSignature));
 
@@ skipping 193 matching lines @@
        it != network_configs_onc.end(); ++it) {
     const base::DictionaryValue* network = NULL;
     (*it)->GetAsDictionary(&network);
     DCHECK(network);
 
     std::string guid;
     network->GetStringWithoutPathExpansion(::onc::network_config::kGUID, &guid);
     DCHECK(!guid.empty());
 
     if (policies->per_network_config.count(guid) > 0) {
-      LOG(ERROR) << "ONC from " << ToDebugString(onc_source, userhash)
-                 << " contains several entries for the same GUID "
-                 << guid << ".";
+      NET_LOG_ERROR("ONC from " + ToDebugString(onc_source, userhash) +
+                    " contains several entries for the same GUID ", guid);
       delete policies->per_network_config[guid];
     }
     const base::DictionaryValue* new_entry = network->DeepCopy();
     policies->per_network_config[guid] = new_entry;
 
     const base::DictionaryValue* old_entry = old_per_network_config[guid];
     if (!old_entry || !old_entry->Equals(new_entry))
       modified_policies.insert(guid);
   }
 
@@ skipping 61 matching lines @@
 void ManagedNetworkConfigurationHandlerImpl::
     UpdateExistingConfigurationWithPropertiesFromPolicy(
         const base::DictionaryValue& existing_properties,
         const base::DictionaryValue& new_properties) {
   base::DictionaryValue shill_properties;
 
   std::string profile;
   existing_properties.GetStringWithoutPathExpansion(shill::kProfileProperty,
                                                     &profile);
   if (profile.empty()) {
-    LOG(ERROR) << "Missing profile property.";
+    NET_LOG_ERROR("Missing profile property",
+                  shill_property_util::GetNetworkIdFromProperties(
+                      existing_properties));
     return;
   }
   shill_properties.SetStringWithoutPathExpansion(shill::kProfileProperty,
                                                  profile);
 
   if (!shill_property_util::CopyIdentifyingProperties(existing_properties,
                                                       &shill_properties)) {
-    LOG(ERROR) << "Missing identifying properties.";
+    NET_LOG_ERROR("Missing identifying properties",
+                  shill_property_util::GetNetworkIdFromProperties(
+                      existing_properties));
   }
 
   shill_properties.MergeDictionary(&new_properties);
 
   network_configuration_handler_->CreateConfiguration(
       shill_properties,
       base::Bind(
           &ManagedNetworkConfigurationHandlerImpl::OnPolicyAppliedToNetwork,
           weak_ptr_factory_.GetWeakPtr()),
       base::Bind(&LogErrorWithDict, FROM_HERE));
@@ skipping 46 matching lines @@
 
   return &policies->global_network_config;
 }
 const base::DictionaryValue*
 ManagedNetworkConfigurationHandlerImpl::FindPolicyByGuidAndProfile(
     const std::string& guid,
     const std::string& profile_path) const {
   const NetworkProfile* profile =
       network_profile_handler_->GetProfileForPath(profile_path);
   if (!profile) {
-    LOG(ERROR) << "Profile path unknown: " << profile_path;
+    NET_LOG_ERROR("Profile path unknown:" + profile_path, guid);
     return NULL;
   }
 
   const Policies* policies = GetPoliciesForProfile(*profile);
   if (!policies)
     return NULL;
 
   return GetByGUID(policies->per_network_config, guid);
 }
 
@@ skipping 37 matching lines @@
 
 void ManagedNetworkConfigurationHandlerImpl::OnPolicyAppliedToNetwork(
     const std::string& service_path) {
   if (service_path.empty())
     return;
   FOR_EACH_OBSERVER(
       NetworkPolicyObserver, observers_, PolicyApplied(service_path));
 }
 
 }  // namespace chromeos