Change 'LOG(ERROR)' to 'VLOG(1)' in mojo bits.

services/catalog/entry.cc

 // Copyright 2016 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 "services/catalog/entry.h"
 
 #include "base/memory/ptr_util.h"
 #include "base/values.h"
 #include "services/catalog/store.h"
 #include "services/service_manager/public/cpp/names.h"
 
 namespace catalog {
 namespace {
 
 bool ReadStringSet(const base::ListValue& list_value,
                    std::set<std::string>* string_set) {
   DCHECK(string_set);
   for (const auto& value_value : list_value) {
     std::string value;
     if (!value_value->GetAsString(&value)) {
-      LOG(ERROR) << "Entry::Deserialize: list member must be a string";
+      VLOG(1) << "Entry::Deserialize: list member must be a string";
       return false;
     }
     string_set->insert(value);
   }
   return true;
 }
 
 bool ReadStringSetFromValue(const base::Value& value,
                             std::set<std::string>* string_set) {
   const base::ListValue* list_value = nullptr;
   if (!value.GetAsList(&list_value)) {
-    LOG(ERROR) << "Entry::Deserialize: Value must be a list.";
+    VLOG(1) << "Entry::Deserialize: Value must be a list.";
     return false;
   }
   return ReadStringSet(*list_value, string_set);
 }
 
 bool BuildInterfaceProviderSpec(
     const base::DictionaryValue& value,
     service_manager::InterfaceProviderSpec* interface_provider_specs) {
   DCHECK(interface_provider_specs);
   const base::DictionaryValue* provides_value = nullptr;
   if (value.HasKey(Store::kInterfaceProviderSpecs_ProvidesKey) &&
       !value.GetDictionary(Store::kInterfaceProviderSpecs_ProvidesKey,
                            &provides_value)) {
-    LOG(ERROR) << "Entry::Deserialize: "
+    VLOG(1) << "Entry::Deserialize: "
                << Store::kInterfaceProviderSpecs_ProvidesKey
                << " must be a dictionary.";
     return false;
   }
   if (provides_value) {
     base::DictionaryValue::Iterator it(*provides_value);
     for(; !it.IsAtEnd(); it.Advance()) {
       service_manager::InterfaceSet interfaces;
       if (!ReadStringSetFromValue(it.value(), &interfaces)) {
-        LOG(ERROR) << "Entry::Deserialize: Invalid interface list in provided "
+        VLOG(1) << "Entry::Deserialize: Invalid interface list in provided "
                    << " capabilities dictionary";
         return false;
       }
       interface_provider_specs->provides[it.key()] = interfaces;
     }
   }
 
   const base::DictionaryValue* requires_value = nullptr;
   if (value.HasKey(Store::kInterfaceProviderSpecs_RequiresKey) &&
       !value.GetDictionary(Store::kInterfaceProviderSpecs_RequiresKey,
                            &requires_value)) {
-    LOG(ERROR) << "Entry::Deserialize: "
+    VLOG(1) << "Entry::Deserialize: "
                << Store::kInterfaceProviderSpecs_RequiresKey
                << " must be a dictionary.";
     return false;
   }
   if (requires_value) {
     base::DictionaryValue::Iterator it(*requires_value);
     for (; !it.IsAtEnd(); it.Advance()) {
       service_manager::CapabilitySet capabilities;
       const base::ListValue* entry_value = nullptr;
       if (!it.value().GetAsList(&entry_value)) {
-        LOG(ERROR) << "Entry::Deserialize: "
+        VLOG(1) << "Entry::Deserialize: "
                    << Store::kInterfaceProviderSpecs_RequiresKey
                    << " entry must be a list.";
         return false;
       }
       if (!ReadStringSet(*entry_value, &capabilities)) {
-        LOG(ERROR) << "Entry::Deserialize: Invalid capabilities list in "
+        VLOG(1) << "Entry::Deserialize: Invalid capabilities list in "
                    << "requires dictionary.";
         return false;
       }
 
       interface_provider_specs->requires[it.key()] = capabilities;
     }
   }
   return true;
 }
 
@@ skipping 37 matching lines @@
   return value;
 }
 
 // static
 std::unique_ptr<Entry> Entry::Deserialize(const base::DictionaryValue& value) {
   auto entry = base::MakeUnique<Entry>();
 
   // Name.
   std::string name_string;
   if (!value.GetString(Store::kNameKey, &name_string)) {
-    LOG(ERROR) << "Entry::Deserialize: dictionary has no "
+    VLOG(1) << "Entry::Deserialize: dictionary has no "
                << Store::kNameKey << " key";
     return nullptr;
   }
   if (!service_manager::IsValidName(name_string)) {
-    LOG(ERROR) << "Entry::Deserialize: " << name_string << " is not a valid "
+    VLOG(1) << "Entry::Deserialize: " << name_string << " is not a valid "
                << "Mojo name";
     return nullptr;
   }
   entry->set_name(name_string);
 
   // Human-readable name.
   std::string display_name;
   if (!value.GetString(Store::kDisplayNameKey, &display_name)) {
-    LOG(ERROR) << "Entry::Deserialize: dictionary has no "
+    VLOG(1) << "Entry::Deserialize: dictionary has no "
                << Store::kDisplayNameKey << " key";
     return nullptr;
   }
   entry->set_display_name(display_name);
 
   // InterfaceProvider specs.
   const base::DictionaryValue* interface_provider_specs = nullptr;
   if (!value.GetDictionary(Store::kInterfaceProviderSpecsKey,
                            &interface_provider_specs)) {
-    LOG(ERROR) << "Entry::Deserialize: dictionary has no "
+    VLOG(1) << "Entry::Deserialize: dictionary has no "
                << Store::kInterfaceProviderSpecsKey << " key";
     return nullptr;
   }
 
   base::DictionaryValue::Iterator it(*interface_provider_specs);
   for (; !it.IsAtEnd(); it.Advance()) {
     const base::DictionaryValue* spec_value = nullptr;
     if (!interface_provider_specs->GetDictionary(it.key(), &spec_value)) {
-      LOG(ERROR) << "Entry::Deserialize: value of InterfaceProvider map for "
+      VLOG(1) << "Entry::Deserialize: value of InterfaceProvider map for "
                  << "key: " << it.key() << " not a dictionary.";
       return nullptr;
     }
 
     service_manager::InterfaceProviderSpec spec;
     if (!BuildInterfaceProviderSpec(*spec_value, &spec)) {
-      LOG(ERROR) << "Entry::Deserialize: failed to build InterfaceProvider "
+      VLOG(1) << "Entry::Deserialize: failed to build InterfaceProvider "
                  << "spec for key: " << it.key();
       return nullptr;
     }
     entry->AddInterfaceProviderSpec(it.key(), spec);
   }
 
   if (value.HasKey(Store::kServicesKey)) {
     const base::ListValue* services = nullptr;
     value.GetList(Store::kServicesKey, &services);
     for (size_t i = 0; i < services->GetSize(); ++i) {
@@ skipping 62 matching lines @@
 catalog::mojom::EntryPtr
     TypeConverter<catalog::mojom::EntryPtr, catalog::Entry>::Convert(
         const catalog::Entry& input) {
   catalog::mojom::EntryPtr result(catalog::mojom::Entry::New());
   result->name = input.name();
   result->display_name = input.display_name();
   return result;
 }
 
 }  // namespace mojo