Restore BLUETOOTH_LOG and convert bluetooth_adapter_bluez to use it

components/device_event_log/device_event_log_impl.cc

 // Copyright 2014 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 "components/device_event_log/device_event_log_impl.h"
 
 #include <cmath>
 #include <list>
 #include <set>
 
@@ skipping 11 matching lines @@
 
 namespace device_event_log {
 
 namespace {
 
 const char* kLogLevelName[] = {"Error", "User", "Event", "Debug"};
 
 const char* kLogTypeNetworkDesc = "Network";
 const char* kLogTypePowerDesc = "Power";
 const char* kLogTypeLoginDesc = "Login";
+const char* kLogTypeBluetoothDesc = "Bluetooth";
 const char* kLogTypeUsbDesc = "USB";
 const char* kLogTypeHidDesc = "HID";
 
 std::string GetLogTypeString(LogType type) {
   switch (type) {
     case LOG_TYPE_NETWORK:
       return kLogTypeNetworkDesc;
     case LOG_TYPE_POWER:
       return kLogTypePowerDesc;
     case LOG_TYPE_LOGIN:
       return kLogTypeLoginDesc;
+    case LOG_TYPE_BLUETOOTH:
+      return kLogTypeBluetoothDesc;
     case LOG_TYPE_USB:
       return kLogTypeUsbDesc;
     case LOG_TYPE_HID:
       return kLogTypeHidDesc;
-    default:
-      NOTREACHED();
-      return "Unknown";
+    case LOG_TYPE_UNKNOWN:
+      break;
   }
+  NOTREACHED();
+  return "Unknown";
+}
+
+LogType GetLogTypeFromString(const std::string& desc) {
+  std::string desc_lc = base::ToLowerASCII(desc);
+  for (int i = 0; i < LOG_TYPE_UNKNOWN; ++i) {
+    auto type = static_cast<LogType>(i);
+    std::string log_desc_lc = base::ToLowerASCII(GetLogTypeString(type));
+    if (desc_lc == log_desc_lc)
+      return type;
+  }
+  NOTREACHED() << "Unrecogized LogType: " << desc;
+  return LOG_TYPE_UNKNOWN;
 }
 
 std::string DateAndTimeWithMicroseconds(const base::Time& time) {
   base::Time::Exploded exploded;
   time.LocalExplode(&exploded);
   // base::Time::Exploded does not include microseconds, but sometimes we need
   // microseconds, so append '.' + usecs to the end of the formatted string.
   int usecs = static_cast<int>(fmod(time.ToDoubleT() * 1000000, 1000000));
   return base::StringPrintf("%04d/%02d/%02d %02d:%02d:%02d.%06d", exploded.year,
                             exploded.month, exploded.day_of_month,
@@ skipping 117 matching lines @@
       *show_file = true;
     if (tok == "type")
       *show_type = true;
     if (tok == "level")
       *show_level = true;
     if (tok == "json")
       *format_json = true;
   }
 }
 
-LogType LogTypeFromString(const std::string& desc) {
-  std::string desc_lc = base::ToLowerASCII(desc);
-  if (desc_lc == "network")
-    return LOG_TYPE_NETWORK;
-  if (desc_lc == "power")
-    return LOG_TYPE_POWER;
-  if (desc_lc == "login")
-    return LOG_TYPE_LOGIN;
-  NOTREACHED() << "Unrecogized LogType: " << desc;
-  return LOG_TYPE_UNKNOWN;
-}
-
 void GetLogTypes(const std::string& types,
                  std::set<LogType>* include_types,
                  std::set<LogType>* exclude_types) {
   base::StringTokenizer tokens(types, ",");
   while (tokens.GetNext()) {
     std::string tok(tokens.token());
     if (tok.substr(0, 4) == "non-") {
-      LogType type = LogTypeFromString(tok.substr(4));
+      LogType type = GetLogTypeFromString(tok.substr(4));
       if (type != LOG_TYPE_UNKNOWN)
         exclude_types->insert(type);
     } else {
-      LogType type = LogTypeFromString(tok);
+      LogType type = GetLogTypeFromString(tok);
       if (type != LOG_TYPE_UNKNOWN)
         include_types->insert(type);
     }
   }
 }
 
 // Update count and time for identical events to avoid log spam.
 void IncreaseLogEntryCount(const DeviceEventLogImpl::LogEntry& new_entry,
                            DeviceEventLogImpl::LogEntry* cur_entry) {
   ++cur_entry->count;
@@ skipping 169 matching lines @@
     size_t last_slash_pos = file.find_last_of("\\/");
     if (last_slash_pos != std::string::npos) {
       file.erase(0, last_slash_pos + 1);
     }
   }
 }
 
 DeviceEventLogImpl::LogEntry::LogEntry(const LogEntry& other) = default;
 
 }  // namespace device_event_log