Restore BLUETOOTH_LOG and convert bluetooth_adapter_bluez to use it

device/bluetooth/bluez/bluetooth_adapter_bluez.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 "device/bluetooth/bluez/bluetooth_adapter_bluez.h"
 
 #include <algorithm>
 #include <cstdint>
 #include <limits>
 #include <memory>
 #include <set>
 #include <string>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/memory/ptr_util.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/sequenced_task_runner.h"
 #include "base/single_thread_task_runner.h"
 #include "base/strings/stringprintf.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "base/time/time.h"
 #include "build/build_config.h"
+#include "components/device_event_log/device_event_log.h"
 #include "device/bluetooth/bluetooth_common.h"
 #include "device/bluetooth/bluetooth_device.h"
 #include "device/bluetooth/bluetooth_discovery_session_outcome.h"
 #include "device/bluetooth/bluetooth_socket_thread.h"
 #include "device/bluetooth/bluetooth_uuid.h"
 #include "device/bluetooth/bluez/bluetooth_adapter_profile_bluez.h"
 #include "device/bluetooth/bluez/bluetooth_advertisement_bluez.h"
 #include "device/bluetooth/bluez/bluetooth_device_bluez.h"
 #include "device/bluetooth/bluez/bluetooth_gatt_service_bluez.h"
 #include "device/bluetooth/bluez/bluetooth_local_gatt_characteristic_bluez.h"
@@ skipping 29 matching lines @@
 // exist per D-Bus connection, it just has to be unique within Chromium.
 const char kAgentPath[] = "/org/chromium/bluetooth_agent";
 const char kGattApplicationObjectPath[] = "/gatt_application";
 
 void OnUnregisterAgentError(const std::string& error_name,
                             const std::string& error_message) {
   // It's okay if the agent didn't exist, it means we never saw an adapter.
   if (error_name == bluetooth_agent_manager::kErrorDoesNotExist)
     return;
 
-  LOG(WARNING) << "Failed to unregister pairing agent: " << error_name << ": "
-               << error_message;
+  BLUETOOTH_LOG(ERROR) << "Failed to unregister pairing agent: " << error_name
+                       << ": " << error_message;
 }
 
 UMABluetoothDiscoverySessionOutcome TranslateDiscoveryErrorToUMA(
     const std::string& error_name) {
   if (error_name == bluez::BluetoothAdapterClient::kUnknownAdapterError) {
     return UMABluetoothDiscoverySessionOutcome::BLUEZ_DBUS_UNKNOWN_ADAPTER;
   } else if (error_name == bluez::BluetoothAdapterClient::kNoResponseError) {
     return UMABluetoothDiscoverySessionOutcome::BLUEZ_DBUS_NO_RESPONSE;
   } else if (error_name == bluetooth_device::kErrorInProgress) {
     return UMABluetoothDiscoverySessionOutcome::BLUEZ_DBUS_IN_PROGRESS;
   } else if (error_name == bluetooth_device::kErrorNotReady) {
     return UMABluetoothDiscoverySessionOutcome::BLUEZ_DBUS_NOT_READY;
   } else if (error_name == bluetooth_device::kErrorNotSupported) {
     return UMABluetoothDiscoverySessionOutcome::BLUEZ_DBUS_UNSUPPORTED_DEVICE;
   } else if (error_name == bluetooth_device::kErrorFailed) {
     return UMABluetoothDiscoverySessionOutcome::FAILED;
   } else {
-    LOG(WARNING) << "Can't histogram DBus error " << error_name;
+    BLUETOOTH_LOG(ERROR) << "Unrecognized DBus error " << error_name;
     return UMABluetoothDiscoverySessionOutcome::UNKNOWN;
   }
 }
 
 }  // namespace
 
 namespace device {
 
 // static
 base::WeakPtr<BluetoothAdapter> BluetoothAdapter::CreateAdapter(
     const InitCallback& init_callback) {
   return bluez::BluetoothAdapterBlueZ::CreateAdapter(init_callback);
 }
 
 }  // namespace device
 
 namespace bluez {
 
 namespace {
 
 void OnRegisterationErrorCallback(
     const device::BluetoothGattService::ErrorCallback& error_callback,
     bool is_register_callback,
     const std::string& error_name,
     const std::string& error_message) {
   if (is_register_callback) {
-    VLOG(1) << "Failed to Register service: " << error_name << ", "
-            << error_message;
+    BLUETOOTH_LOG(ERROR) << "Failed to Register service: " << error_name << ", "
+                         << error_message;
   } else {
-    VLOG(1) << "Failed to Unregister service: " << error_name << ", "
-            << error_message;
+    BLUETOOTH_LOG(ERROR) << "Failed to Unregister service: " << error_name
+                         << ", " << error_message;
   }
   error_callback.Run(
       BluetoothGattServiceBlueZ::DBusErrorToServiceError(error_name));
 }
 
 void DoNothingOnError(
     device::BluetoothGattService::GattErrorCode /*error_code*/) {}
 void DoNothingOnAdvertisementError(
     device::BluetoothAdvertisement::ErrorCode /*error_code*/) {}
 
 void SetIntervalErrorCallbackConnector(
     const device::BluetoothAdapter::AdvertisementErrorCallback& error_callback,
     const std::string& error_name,
     const std::string& error_message) {
-  LOG(ERROR) << "Error while registering advertisement. error_name = "
-             << error_name << ", error_message = " << error_message;
+  BLUETOOTH_LOG(ERROR) << "Error while registering advertisement. error_name = "
+                       << error_name << ", error_message = " << error_message;
 
   device::BluetoothAdvertisement::ErrorCode code = device::
       BluetoothAdvertisement::ErrorCode::INVALID_ADVERTISEMENT_ERROR_CODE;
   if (error_name == bluetooth_advertising_manager::kErrorInvalidArguments) {
     code = device::BluetoothAdvertisement::ErrorCode::
         ERROR_INVALID_ADVERTISEMENT_INTERVAL;
   }
   error_callback.Run(code);
 }
 
 }  // namespace
 
 // static
 base::WeakPtr<BluetoothAdapter> BluetoothAdapterBlueZ::CreateAdapter(
     const InitCallback& init_callback) {
   BluetoothAdapterBlueZ* adapter = new BluetoothAdapterBlueZ(init_callback);
   return adapter->weak_ptr_factory_.GetWeakPtr();
 }
 
 void BluetoothAdapterBlueZ::Shutdown() {
   if (dbus_is_shutdown_)
     return;
+
+  BLUETOOTH_LOG(EVENT) << "BluetoothAdapterBlueZ::Shutdown";
+
   DCHECK(bluez::BluezDBusManager::IsInitialized())
       << "Call BluetoothAdapterFactory::Shutdown() before "
          "BluezDBusManager::Shutdown().";
 
   // Since we don't initialize anything if Object Manager is not supported,
   // no need to do any clean up.
   if (!bluez::BluezDBusManager::Get()->IsObjectManagerSupported()) {
     dbus_is_shutdown_ = true;
     return;
   }
@@ skipping 26 matching lines @@
   }
   advertisements_.clear();
 
   bluez::BluezDBusManager::Get()->GetBluetoothAdapterClient()->RemoveObserver(
       this);
   bluez::BluezDBusManager::Get()->GetBluetoothDeviceClient()->RemoveObserver(
       this);
   bluez::BluezDBusManager::Get()->GetBluetoothInputClient()->RemoveObserver(
       this);
 
-  VLOG(1) << "Unregistering pairing agent";
+  BLUETOOTH_LOG(EVENT) << "Unregistering pairing agent";
   bluez::BluezDBusManager::Get()
       ->GetBluetoothAgentManagerClient()
       ->UnregisterAgent(dbus::ObjectPath(kAgentPath),
                         base::Bind(&base::DoNothing),
                         base::Bind(&OnUnregisterAgentError));
 
   agent_.reset();
 
   dbus_is_shutdown_ = true;
 }
@@ skipping 38 matching lines @@
   // Register the pairing agent.
   dbus::Bus* system_bus = bluez::BluezDBusManager::Get()->GetSystemBus();
   agent_.reset(bluez::BluetoothAgentServiceProvider::Create(
       system_bus, dbus::ObjectPath(kAgentPath), this));
   DCHECK(agent_.get());
 
   std::vector<dbus::ObjectPath> object_paths = bluez::BluezDBusManager::Get()
                                                    ->GetBluetoothAdapterClient()
                                                    ->GetAdapters();
 
+  BLUETOOTH_LOG(EVENT) << "BlueZ Adapter Initialized.";
   if (!object_paths.empty()) {
-    VLOG(1) << object_paths.size() << " Bluetooth adapter(s) available.";
+    BLUETOOTH_LOG(EVENT) << "BlueZ Adapters available: " << object_paths.size();
     SetAdapter(object_paths[0]);
   }
   initialized_ = true;
   init_callback_.Run();
 }
 
 BluetoothAdapterBlueZ::~BluetoothAdapterBlueZ() {
   Shutdown();
 }
 
@@ skipping 57 matching lines @@
           ->GetBluetoothAdapterClient()
           ->GetProperties(object_path_);
 
   return properties->powered.value();
 }
 
 void BluetoothAdapterBlueZ::SetPowered(bool powered,
                                        const base::Closure& callback,
                                        const ErrorCallback& error_callback) {
   if (!IsPresent()) {
+    BLUETOOTH_LOG(ERROR) << "SetPowered: " << powered << ". Not Present!";
     error_callback.Run();
     return;
   }
 
+  BLUETOOTH_LOG(EVENT) << "SetPowered: " << powered;
+
   bluez::BluezDBusManager::Get()
       ->GetBluetoothAdapterClient()
       ->GetProperties(object_path_)
       ->powered.Set(
           powered,
           base::Bind(&BluetoothAdapterBlueZ::OnPropertyChangeCompleted,
                      weak_ptr_factory_.GetWeakPtr(), callback, error_callback));
 }
 
 bool BluetoothAdapterBlueZ::IsDiscoverable() const {
@@ skipping 10 matching lines @@
 
 void BluetoothAdapterBlueZ::SetDiscoverable(
     bool discoverable,
     const base::Closure& callback,
     const ErrorCallback& error_callback) {
   if (!IsPresent()) {
     error_callback.Run();
     return;
   }
 
+  BLUETOOTH_LOG(EVENT) << "SetDiscoverable: " << discoverable;
+
   bluez::BluezDBusManager::Get()
       ->GetBluetoothAdapterClient()
       ->GetProperties(object_path_)
       ->discoverable.Set(
           discoverable,
           base::Bind(&BluetoothAdapterBlueZ::OnSetDiscoverable,
                      weak_ptr_factory_.GetWeakPtr(), callback, error_callback));
 }
 
 uint32_t BluetoothAdapterBlueZ::GetDiscoverableTimeout() const {
@@ skipping 60 matching lines @@
 
   return UUIDList(uuids.begin(), uuids.end());
 }
 
 void BluetoothAdapterBlueZ::CreateRfcommService(
     const BluetoothUUID& uuid,
     const ServiceOptions& options,
     const CreateServiceCallback& callback,
     const CreateServiceErrorCallback& error_callback) {
   DCHECK(!dbus_is_shutdown_);
-  VLOG(1) << object_path_.value()
-          << ": Creating RFCOMM service: " << uuid.canonical_value();
+  BLUETOOTH_LOG(DEBUG) << object_path_.value() << ": Creating RFCOMM service: "
+                       << uuid.canonical_value();
   scoped_refptr<BluetoothSocketBlueZ> socket =
       BluetoothSocketBlueZ::CreateBluetoothSocket(ui_task_runner_,
                                                   socket_thread_);
   socket->Listen(this, BluetoothSocketBlueZ::kRfcomm, uuid, options,
                  base::Bind(callback, socket), error_callback);
 }
 
 void BluetoothAdapterBlueZ::CreateL2capService(
     const BluetoothUUID& uuid,
     const ServiceOptions& options,
     const CreateServiceCallback& callback,
     const CreateServiceErrorCallback& error_callback) {
   DCHECK(!dbus_is_shutdown_);
-  VLOG(1) << object_path_.value()
-          << ": Creating L2CAP service: " << uuid.canonical_value();
+  BLUETOOTH_LOG(DEBUG) << object_path_.value() << ": Creating L2CAP service: "
+                       << uuid.canonical_value();
   scoped_refptr<BluetoothSocketBlueZ> socket =
       BluetoothSocketBlueZ::CreateBluetoothSocket(ui_task_runner_,
                                                   socket_thread_);
   socket->Listen(this, BluetoothSocketBlueZ::kL2cap, uuid, options,
                  base::Bind(callback, socket), error_callback);
 }
 
 void BluetoothAdapterBlueZ::RegisterAdvertisement(
     std::unique_ptr<device::BluetoothAdvertisement::Data> advertisement_data,
     const CreateAdvertisementCallback& callback,
@@ skipping 119 matching lines @@
     return;
 
   bluez::BluetoothDeviceClient::Properties* properties =
       bluez::BluezDBusManager::Get()->GetBluetoothDeviceClient()->GetProperties(
           object_path);
 
   if (property_name == properties->address.name()) {
     for (auto iter = devices_.begin(); iter != devices_.end(); ++iter) {
       if (iter->second->GetAddress() == device_bluez->GetAddress()) {
         std::string old_address = iter->first;
-        VLOG(1) << "Device changed address, old: " << old_address
-                << " new: " << device_bluez->GetAddress();
+        BLUETOOTH_LOG(EVENT) << "Device changed address, old: " << old_address
+                             << " new: " << device_bluez->GetAddress();
         std::unique_ptr<BluetoothDevice> scoped_device =
             std::move(iter->second);
         devices_.erase(iter);
 
         DCHECK(devices_.find(device_bluez->GetAddress()) == devices_.end());
         devices_[device_bluez->GetAddress()] = std::move(scoped_device);
         NotifyDeviceAddressChanged(device_bluez, old_address);
         break;
       }
     }
@@ skipping 63 matching lines @@
 
   // Properties structure can be removed, which triggers a change in the
   // BluetoothDevice::IsConnectable() property, as does a change in the
   // actual reconnect_mode property.
   if (!properties || property_name == properties->reconnect_mode.name()) {
     NotifyDeviceChanged(device_bluez);
   }
 }
 
 void BluetoothAdapterBlueZ::Released() {
-  VLOG(1) << "Release";
+  BLUETOOTH_LOG(EVENT) << "Released";
   if (!IsPresent())
     return;
   DCHECK(agent_.get());
 
   // Called after we unregister the pairing agent, e.g. when changing I/O
   // capabilities. Nothing much to be done right now.
 }
 
 void BluetoothAdapterBlueZ::RequestPinCode(const dbus::ObjectPath& device_path,
                                            const PinCodeCallback& callback) {
   DCHECK(IsPresent());
   DCHECK(agent_.get());
-  VLOG(1) << device_path.value() << ": RequestPinCode";
+  BLUETOOTH_LOG(EVENT) << device_path.value() << ": RequestPinCode";
 
   BluetoothPairingBlueZ* pairing = GetPairing(device_path);
   if (!pairing) {
     callback.Run(REJECTED, "");
     return;
   }
 
   pairing->RequestPinCode(callback);
 }
 
 void BluetoothAdapterBlueZ::DisplayPinCode(const dbus::ObjectPath& device_path,
                                            const std::string& pincode) {
   DCHECK(IsPresent());
   DCHECK(agent_.get());
-  VLOG(1) << device_path.value() << ": DisplayPinCode: " << pincode;
+  BLUETOOTH_LOG(EVENT) << device_path.value()
+                       << ": DisplayPinCode: " << pincode;
 
   BluetoothPairingBlueZ* pairing = GetPairing(device_path);
   if (!pairing)
     return;
 
   pairing->DisplayPinCode(pincode);
 }
 
 void BluetoothAdapterBlueZ::RequestPasskey(const dbus::ObjectPath& device_path,
                                            const PasskeyCallback& callback) {
   DCHECK(IsPresent());
   DCHECK(agent_.get());
-  VLOG(1) << device_path.value() << ": RequestPasskey";
+  BLUETOOTH_LOG(EVENT) << device_path.value() << ": RequestPasskey";
 
   BluetoothPairingBlueZ* pairing = GetPairing(device_path);
   if (!pairing) {
     callback.Run(REJECTED, 0);
     return;
   }
 
   pairing->RequestPasskey(callback);
 }
 
 void BluetoothAdapterBlueZ::DisplayPasskey(const dbus::ObjectPath& device_path,
                                            uint32_t passkey,
                                            uint16_t entered) {
   DCHECK(IsPresent());
   DCHECK(agent_.get());
-  VLOG(1) << device_path.value() << ": DisplayPasskey: " << passkey << " ("
-          << entered << " entered)";
+  BLUETOOTH_LOG(EVENT) << device_path.value() << ": DisplayPasskey: " << passkey
+                       << " (" << entered << " entered)";
 
   BluetoothPairingBlueZ* pairing = GetPairing(device_path);
   if (!pairing)
     return;
 
   if (entered == 0)
     pairing->DisplayPasskey(passkey);
 
   pairing->KeysEntered(entered);
 }
 
 void BluetoothAdapterBlueZ::RequestConfirmation(
     const dbus::ObjectPath& device_path,
     uint32_t passkey,
     const ConfirmationCallback& callback) {
   DCHECK(IsPresent());
   DCHECK(agent_.get());
-  VLOG(1) << device_path.value() << ": RequestConfirmation: " << passkey;
+  BLUETOOTH_LOG(EVENT) << device_path.value()
+                       << ": RequestConfirmation: " << passkey;
 
   BluetoothPairingBlueZ* pairing = GetPairing(device_path);
   if (!pairing) {
     callback.Run(REJECTED);
     return;
   }
 
   pairing->RequestConfirmation(passkey, callback);
 }
 
 void BluetoothAdapterBlueZ::RequestAuthorization(
     const dbus::ObjectPath& device_path,
     const ConfirmationCallback& callback) {
   DCHECK(IsPresent());
   DCHECK(agent_.get());
-  VLOG(1) << device_path.value() << ": RequestAuthorization";
+  BLUETOOTH_LOG(EVENT) << device_path.value() << ": RequestAuthorization";
 
   BluetoothPairingBlueZ* pairing = GetPairing(device_path);
   if (!pairing) {
     callback.Run(REJECTED);
     return;
   }
 
   pairing->RequestAuthorization(callback);
 }
 
 void BluetoothAdapterBlueZ::AuthorizeService(
     const dbus::ObjectPath& device_path,
     const std::string& uuid,
     const ConfirmationCallback& callback) {
   DCHECK(IsPresent());
   DCHECK(agent_.get());
-  VLOG(1) << device_path.value() << ": AuthorizeService: " << uuid;
+  BLUETOOTH_LOG(EVENT) << device_path.value() << ": AuthorizeService: " << uuid;
 
   BluetoothDeviceBlueZ* device_bluez = GetDeviceWithPath(device_path);
   if (!device_bluez) {
     callback.Run(CANCELLED);
     return;
   }
 
   // We always set paired devices to Trusted, so the only reason that this
   // method call would ever be called is in the case of a race condition where
   // our "Set('Trusted', true)" method call is still pending in the Bluetooth
   // daemon because it's busy handling the incoming connection.
   if (device_bluez->IsPaired()) {
     callback.Run(SUCCESS);
     return;
   }
 
   // TODO(keybuk): reject service authorizations when not paired, determine
   // whether this is acceptable long-term.
-  LOG(WARNING) << "Rejecting service connection from unpaired device "
-               << device_bluez->GetAddress() << " for UUID " << uuid;
+  BLUETOOTH_LOG(ERROR) << "Rejecting service connection from unpaired device "
+                       << device_bluez->GetAddress() << " for UUID " << uuid;
   callback.Run(REJECTED);
 }
 
 void BluetoothAdapterBlueZ::Cancel() {
   DCHECK(IsPresent());
   DCHECK(agent_.get());
-  VLOG(1) << "Cancel";
+  BLUETOOTH_LOG(EVENT) << "Cancel";
 }
 
 void BluetoothAdapterBlueZ::OnRegisterAgent() {
-  VLOG(1) << "Pairing agent registered, requesting to be made default";
+  BLUETOOTH_LOG(EVENT)
+      << "Pairing agent registered, requesting to be made default";
 
   bluez::BluezDBusManager::Get()
       ->GetBluetoothAgentManagerClient()
       ->RequestDefaultAgent(
           dbus::ObjectPath(kAgentPath),
           base::Bind(&BluetoothAdapterBlueZ::OnRequestDefaultAgent,
                      weak_ptr_factory_.GetWeakPtr()),
           base::Bind(&BluetoothAdapterBlueZ::OnRequestDefaultAgentError,
                      weak_ptr_factory_.GetWeakPtr()));
 }
 
 void BluetoothAdapterBlueZ::OnRegisterAgentError(
     const std::string& error_name,
     const std::string& error_message) {
   // Our agent being already registered isn't an error.
   if (error_name == bluetooth_agent_manager::kErrorAlreadyExists)
     return;
 
-  LOG(WARNING) << ": Failed to register pairing agent: " << error_name << ": "
-               << error_message;
+  BLUETOOTH_LOG(ERROR) << "Failed to register pairing agent: " << error_name
+                       << ": " << error_message;
 }
 
 void BluetoothAdapterBlueZ::OnRequestDefaultAgent() {
-  VLOG(1) << "Pairing agent now default";
+  BLUETOOTH_LOG(EVENT) << "Pairing agent now default";
 }
 
 void BluetoothAdapterBlueZ::OnRequestDefaultAgentError(
     const std::string& error_name,
     const std::string& error_message) {
-  LOG(WARNING) << ": Failed to make pairing agent default: " << error_name
-               << ": " << error_message;
+  BLUETOOTH_LOG(ERROR) << "Failed to make pairing agent default: " << error_name
+                       << ": " << error_message;
 }
 
 void BluetoothAdapterBlueZ::CreateServiceRecord(
     const BluetoothServiceRecordBlueZ& record,
     const ServiceRecordCallback& callback,
     const ServiceRecordErrorCallback& error_callback) {
   bluez::BluezDBusManager::Get()
       ->GetBluetoothAdapterClient()
       ->CreateServiceRecord(
           object_path_, record, callback,
@@ skipping 26 matching lines @@
   }
 
   return nullptr;
 }
 
 BluetoothPairingBlueZ* BluetoothAdapterBlueZ::GetPairing(
     const dbus::ObjectPath& object_path) {
   DCHECK(IsPresent());
   BluetoothDeviceBlueZ* device_bluez = GetDeviceWithPath(object_path);
   if (!device_bluez) {
-    LOG(WARNING) << "Pairing Agent request for unknown device: "
-                 << object_path.value();
+    BLUETOOTH_LOG(ERROR) << "Pairing Agent request for unknown device: "
+                         << object_path.value();
     return nullptr;
   }
 
   BluetoothPairingBlueZ* pairing = device_bluez->GetPairing();
   if (pairing)
     return pairing;
 
   // The device doesn't have its own pairing context, so this is an incoming
   // pairing request that should use our best default delegate (if we have one).
   BluetoothDevice::PairingDelegate* pairing_delegate = DefaultPairingDelegate();
   if (!pairing_delegate)
     return nullptr;
 
   return device_bluez->BeginPairing(pairing_delegate);
 }
 
 void BluetoothAdapterBlueZ::SetAdapter(const dbus::ObjectPath& object_path) {
   DCHECK(!IsPresent());
   DCHECK(!dbus_is_shutdown_);
   object_path_ = object_path;
 
-  VLOG(1) << object_path_.value() << ": using adapter.";
+  BLUETOOTH_LOG(EVENT) << object_path_.value() << ": using adapter.";
 
-  VLOG(1) << "Registering pairing agent";
+  BLUETOOTH_LOG(DEBUG) << "Registering pairing agent";
   bluez::BluezDBusManager::Get()
       ->GetBluetoothAgentManagerClient()
       ->RegisterAgent(dbus::ObjectPath(kAgentPath),
                       bluetooth_agent_manager::kKeyboardDisplayCapability,
                       base::Bind(&BluetoothAdapterBlueZ::OnRegisterAgent,
                                  weak_ptr_factory_.GetWeakPtr()),
                       base::Bind(&BluetoothAdapterBlueZ::OnRegisterAgentError,
                                  weak_ptr_factory_.GetWeakPtr()));
 
 #if defined(OS_CHROMEOS)
@@ skipping 52 matching lines @@
   const std::string address = GetAddress();
   alias = base::StringPrintf(
       "%s_%04X", alias.c_str(),
       base::SuperFastHash(address.data(), address.size()) & 0xFFFF);
   SetName(alias, base::Bind(&base::DoNothing), base::Bind(&base::DoNothing));
 }
 #endif
 
 void BluetoothAdapterBlueZ::RemoveAdapter() {
   DCHECK(IsPresent());
-  VLOG(1) << object_path_.value() << ": adapter removed.";
+  BLUETOOTH_LOG(EVENT) << object_path_.value() << ": adapter removed.";
 
   bluez::BluetoothAdapterClient::Properties* properties =
       bluez::BluezDBusManager::Get()
           ->GetBluetoothAdapterClient()
           ->GetProperties(object_path_);
 
   object_path_ = dbus::ObjectPath("");
 
   if (properties->powered.value())
     NotifyAdapterPoweredChanged(false);
@@ skipping 17 matching lines @@
 }
 
 void BluetoothAdapterBlueZ::DiscoverableChanged(bool discoverable) {
   for (auto& observer : observers_)
     observer.AdapterDiscoverableChanged(this, discoverable);
 }
 
 void BluetoothAdapterBlueZ::DiscoveringChanged(bool discovering) {
   // If the adapter stopped discovery due to a reason other than a request by
   // us, reset the count to 0.
-  VLOG(1) << "Discovering changed: " << discovering;
+  BLUETOOTH_LOG(EVENT) << "Discovering changed: " << discovering;
   if (!discovering && !discovery_request_pending_ &&
       num_discovery_sessions_ > 0) {
-    VLOG(1) << "Marking sessions as inactive.";
+    BLUETOOTH_LOG(DEBUG) << "Marking sessions as inactive.";
     num_discovery_sessions_ = 0;
     MarkDiscoverySessionsAsInactive();
   }
   for (auto& observer : observers_)
     observer.AdapterDiscoveringChanged(this, discovering);
 }
 
 void BluetoothAdapterBlueZ::PresentChanged(bool present) {
   for (auto& observer : observers_)
     observer.AdapterPresentChanged(this, present);
@@ skipping 11 matching lines @@
 void BluetoothAdapterBlueZ::UseProfile(
     const BluetoothUUID& uuid,
     const dbus::ObjectPath& device_path,
     const bluez::BluetoothProfileManagerClient::Options& options,
     bluez::BluetoothProfileServiceProvider::Delegate* delegate,
     const ProfileRegisteredCallback& success_callback,
     const ErrorCompletionCallback& error_callback) {
   DCHECK(delegate);
 
   if (!IsPresent()) {
-    VLOG(2) << "Adapter not present, erroring out";
+    BLUETOOTH_LOG(DEBUG) << "Adapter not present, erroring out";
     error_callback.Run("Adapter not present");
     return;
   }
 
   if (profiles_.find(uuid) != profiles_.end()) {
     // TODO(jamuraa) check that the options are the same and error when they are
     // not.
     SetProfileDelegate(uuid, device_path, delegate, success_callback,
                        error_callback);
     return;
@@ skipping 10 matching lines @@
 
   profile_queues_[uuid]->push_back(std::make_pair(
       base::Bind(&BluetoothAdapterBlueZ::SetProfileDelegate, this, uuid,
                  device_path, delegate, success_callback, error_callback),
       error_callback));
 }
 
 void BluetoothAdapterBlueZ::ReleaseProfile(
     const dbus::ObjectPath& device_path,
     BluetoothAdapterProfileBlueZ* profile) {
-  VLOG(2) << "Releasing Profile: " << profile->uuid().canonical_value()
-          << " from " << device_path.value();
+  BLUETOOTH_LOG(EVENT) << "Releasing Profile: "
+                       << profile->uuid().canonical_value() << " from "
+                       << device_path.value();
   BluetoothUUID uuid = profile->uuid();
   auto iter = profiles_.find(uuid);
   if (iter == profiles_.end()) {
-    LOG(ERROR) << "Profile not found for: " << uuid.canonical_value();
+    BLUETOOTH_LOG(ERROR) << "Profile not found for: " << uuid.canonical_value();
     return;
   }
   released_profiles_[uuid] = iter->second;
   profiles_.erase(iter);
   profile->RemoveDelegate(device_path,
                           base::Bind(&BluetoothAdapterBlueZ::RemoveProfile,
                                      weak_ptr_factory_.GetWeakPtr(), uuid));
 }
 
 void BluetoothAdapterBlueZ::RemoveProfile(const BluetoothUUID& uuid) {
-  VLOG(2) << "Remove Profile: " << uuid.canonical_value();
+  BLUETOOTH_LOG(EVENT) << "Remove Profile: " << uuid.canonical_value();
 
   auto iter = released_profiles_.find(uuid);
   if (iter == released_profiles_.end()) {
-    LOG(ERROR) << "Released Profile not found: " << uuid.canonical_value();
+    BLUETOOTH_LOG(ERROR) << "Released Profile not found: "
+                         << uuid.canonical_value();
     return;
   }
   delete iter->second;
   released_profiles_.erase(iter);
 }
 
 void BluetoothAdapterBlueZ::AddLocalGattService(
     std::unique_ptr<BluetoothLocalGattServiceBlueZ> service) {
   owned_gatt_services_[service->object_path()] = std::move(service);
 }
 
 void BluetoothAdapterBlueZ::RemoveLocalGattService(
     BluetoothLocalGattServiceBlueZ* service) {
   auto service_iter = owned_gatt_services_.find(service->object_path());
   if (service_iter == owned_gatt_services_.end()) {
-    LOG(WARNING) << "Trying to remove service: "
-                 << service->object_path().value()
-                 << " from adapter: " << object_path_.value()
-                 << " that doesn't own it.";
+    BLUETOOTH_LOG(ERROR) << "Trying to remove service: "
+                         << service->object_path().value()
+                         << " from adapter: " << object_path_.value()
+                         << " that doesn't own it.";
     return;
   }
 
   if (registered_gatt_services_.count(service->object_path()) != 0) {
     registered_gatt_services_.erase(service->object_path());
     UpdateRegisteredApplication(true, base::Bind(&base::DoNothing),
                                 base::Bind(&DoNothingOnError));
   }
 
   owned_gatt_services_.erase(service_iter);
 }
 
 void BluetoothAdapterBlueZ::RegisterGattService(
     BluetoothLocalGattServiceBlueZ* service,
     const base::Closure& callback,
     const device::BluetoothGattService::ErrorCallback& error_callback) {
   if (registered_gatt_services_.count(service->object_path()) > 0) {
-    LOG(WARNING) << "Re-registering a service that is already registered!";
+    BLUETOOTH_LOG(ERROR)
+        << "Re-registering a service that is already registered!";
     error_callback.Run(device::BluetoothGattService::GATT_ERROR_FAILED);
     return;
   }
 
   registered_gatt_services_[service->object_path()] = service;
 
   // Always assume that we were already registered. If we weren't registered
   // we'll just get an error back which we can ignore. Any other approach will
   // introduce a race since we will always have a period when we may have been
   // registered with BlueZ, but not know that the registration succeeded
   // because the callback hasn't come back yet.
   UpdateRegisteredApplication(true, callback, error_callback);
 }
 
 void BluetoothAdapterBlueZ::UnregisterGattService(
     BluetoothLocalGattServiceBlueZ* service,
     const base::Closure& callback,
     const device::BluetoothGattService::ErrorCallback& error_callback) {
   DCHECK(bluez::BluezDBusManager::Get());
 
   if (registered_gatt_services_.count(service->object_path()) == 0) {
-    LOG(WARNING) << "Unregistering a service that isn't registered! path: "
-                 << service->object_path().value();
+    BLUETOOTH_LOG(ERROR)
+        << "Unregistering a service that isn't registered! path: "
+        << service->object_path().value();
     error_callback.Run(device::BluetoothGattService::GATT_ERROR_FAILED);
     return;
   }
 
   registered_gatt_services_.erase(service->object_path());
   UpdateRegisteredApplication(false, callback, error_callback);
 }
 
 bool BluetoothAdapterBlueZ::IsGattServiceRegistered(
     BluetoothLocalGattServiceBlueZ* service) {
@@ skipping 47 matching lines @@
     return;
   }
   // Already set
   error_callback.Run(bluetooth_agent_manager::kErrorAlreadyExists);
 }
 
 void BluetoothAdapterBlueZ::OnRegisterProfileError(
     const BluetoothUUID& uuid,
     const std::string& error_name,
     const std::string& error_message) {
-  VLOG(2) << object_path_.value()
-          << ": Failed to register profile: " << error_name << ": "
-          << error_message;
+  BLUETOOTH_LOG(ERROR) << object_path_.value()
+                       << ": Failed to register profile: " << error_name << ": "
+                       << error_message;
   if (profile_queues_.find(uuid) == profile_queues_.end())
     return;
 
   for (auto& it : *profile_queues_[uuid])
     it.second.Run(error_message);
 
   delete profile_queues_[uuid];
   profile_queues_.erase(uuid);
 }
 
@@ skipping 30 matching lines @@
 
 void BluetoothAdapterBlueZ::AddDiscoverySession(
     BluetoothDiscoveryFilter* discovery_filter,
     const base::Closure& callback,
     const DiscoverySessionErrorCallback& error_callback) {
   if (!IsPresent()) {
     error_callback.Run(
         UMABluetoothDiscoverySessionOutcome::ADAPTER_NOT_PRESENT);
     return;
   }
-  VLOG(1) << __func__;
+  BLUETOOTH_LOG(EVENT) << __func__;
   if (discovery_request_pending_) {
     // The pending request is either to stop a previous session or to start a
     // new one. Either way, queue this one.
     DCHECK(num_discovery_sessions_ == 1 || num_discovery_sessions_ == 0);
-    VLOG(1) << "Pending request to start/stop device discovery. Queueing "
-            << "request to start a new discovery session.";
+    BLUETOOTH_LOG(DEBUG)
+        << "Pending request to start/stop device discovery. Queueing "
+        << "request to start a new discovery session.";
     discovery_request_queue_.push(
         std::make_tuple(discovery_filter, callback, error_callback));
     return;
   }
 
   // The adapter is already discovering.
   if (num_discovery_sessions_ > 0) {
     DCHECK(IsDiscovering());
     DCHECK(!discovery_request_pending_);
     num_discovery_sessions_++;
@@ skipping 36 matching lines @@
 void BluetoothAdapterBlueZ::RemoveDiscoverySession(
     BluetoothDiscoveryFilter* discovery_filter,
     const base::Closure& callback,
     const DiscoverySessionErrorCallback& error_callback) {
   if (!IsPresent()) {
     error_callback.Run(
         UMABluetoothDiscoverySessionOutcome::ADAPTER_NOT_PRESENT);
     return;
   }
 
-  VLOG(1) << __func__;
+  BLUETOOTH_LOG(EVENT) << __func__;
   // There are active sessions other than the one currently being removed.
   if (num_discovery_sessions_ > 1) {
     DCHECK(IsDiscovering());
     DCHECK(!discovery_request_pending_);
     num_discovery_sessions_--;
 
     SetDiscoveryFilter(GetMergedDiscoveryFilterMasked(discovery_filter),
                        callback, error_callback);
     return;
   }
 
   // If there is a pending request to BlueZ, then queue this request.
   if (discovery_request_pending_) {
-    VLOG(1) << "Pending request to start/stop device discovery. Queueing "
-            << "request to stop discovery session.";
+    BLUETOOTH_LOG(DEBUG)
+        << "Pending request to start/stop device discovery. Queueing "
+        << "request to stop discovery session.";
     error_callback.Run(
         UMABluetoothDiscoverySessionOutcome::REMOVE_WITH_PENDING_REQUEST);
     return;
   }
 
   // There are no active sessions. Return error.
   if (num_discovery_sessions_ == 0) {
     // TODO(armansito): This should never happen once we have the
     // DiscoverySession API. Replace this case with an assert once it's
     // the deprecated methods have been removed. (See crbug.com/3445008).
-    VLOG(1) << "No active discovery sessions. Returning error.";
+    BLUETOOTH_LOG(DEBUG) << "No active discovery sessions. Returning error.";
     error_callback.Run(
         UMABluetoothDiscoverySessionOutcome::ACTIVE_SESSION_NOT_IN_ADAPTER);
     return;
   }
 
   // There is exactly one active discovery session. Request BlueZ to stop
   // discovery.
   DCHECK_EQ(num_discovery_sessions_, 1);
   discovery_request_pending_ = true;
   bluez::BluezDBusManager::Get()->GetBluetoothAdapterClient()->StopDiscovery(
@@ skipping 69 matching lines @@
           base::Bind(&BluetoothAdapterBlueZ::OnSetDiscoveryFilter,
                      weak_ptr_factory_.GetWeakPtr(), callback, error_callback),
           base::Bind(&BluetoothAdapterBlueZ::OnSetDiscoveryFilterError,
                      weak_ptr_factory_.GetWeakPtr(), callback, error_callback));
 }
 
 void BluetoothAdapterBlueZ::OnStartDiscovery(
     const base::Closure& callback,
     const DiscoverySessionErrorCallback& error_callback) {
   // Report success on the original request and increment the count.
-  VLOG(1) << __func__;
+  BLUETOOTH_LOG(EVENT) << __func__;
   DCHECK(discovery_request_pending_);
   DCHECK_EQ(num_discovery_sessions_, 0);
   discovery_request_pending_ = false;
   num_discovery_sessions_++;
   if (IsPresent()) {
     callback.Run();
   } else {
     error_callback.Run(UMABluetoothDiscoverySessionOutcome::ADAPTER_REMOVED);
   }
 
   // Try to add a new discovery session for each queued request.
   ProcessQueuedDiscoveryRequests();
 }
 
 void BluetoothAdapterBlueZ::OnStartDiscoveryError(
     const base::Closure& callback,
     const DiscoverySessionErrorCallback& error_callback,
     const std::string& error_name,
     const std::string& error_message) {
-  LOG(WARNING) << object_path_.value()
-               << ": Failed to start discovery: " << error_name << ": "
-               << error_message;
+  BLUETOOTH_LOG(ERROR) << object_path_.value()
+                       << ": Failed to start discovery: " << error_name << ": "
+                       << error_message;
 
   // Failed to start discovery. This can only happen if the count is at 0.
   DCHECK_EQ(num_discovery_sessions_, 0);
   DCHECK(discovery_request_pending_);
   discovery_request_pending_ = false;
 
   // Discovery request may fail if discovery was previously initiated by Chrome,
   // but the session were invalidated due to the discovery state unexpectedly
   // changing to false and then back to true. In this case, report success.
   if (IsPresent() && error_name == bluetooth_device::kErrorInProgress &&
       IsDiscovering()) {
-    VLOG(1) << "Discovery previously initiated. Reporting success.";
+    BLUETOOTH_LOG(DEBUG)
+        << "Discovery previously initiated. Reporting success.";
     num_discovery_sessions_++;
     callback.Run();
   } else {
     error_callback.Run(TranslateDiscoveryErrorToUMA(error_name));
   }
 
   // Try to add a new discovery session for each queued request.
   ProcessQueuedDiscoveryRequests();
 }
 
 void BluetoothAdapterBlueZ::OnStopDiscovery(const base::Closure& callback) {
   // Report success on the original request and decrement the count.
-  VLOG(1) << __func__;
+  BLUETOOTH_LOG(EVENT) << __func__;
   DCHECK(discovery_request_pending_);
   DCHECK_EQ(num_discovery_sessions_, 1);
   discovery_request_pending_ = false;
   num_discovery_sessions_--;
   callback.Run();
 
   current_filter_.reset();
 
   // Try to add a new discovery session for each queued request.
   ProcessQueuedDiscoveryRequests();
 }
 
 void BluetoothAdapterBlueZ::OnStopDiscoveryError(
     const DiscoverySessionErrorCallback& error_callback,
     const std::string& error_name,
     const std::string& error_message) {
-  LOG(WARNING) << object_path_.value()
-               << ": Failed to stop discovery: " << error_name << ": "
-               << error_message;
+  BLUETOOTH_LOG(ERROR) << object_path_.value()
+                       << ": Failed to stop discovery: " << error_name << ": "
+                       << error_message;
 
   // Failed to stop discovery. This can only happen if the count is at 1.
   DCHECK(discovery_request_pending_);
   DCHECK_EQ(num_discovery_sessions_, 1);
   discovery_request_pending_ = false;
   error_callback.Run(TranslateDiscoveryErrorToUMA(error_name));
 
   // Try to add a new discovery session for each queued request.
   ProcessQueuedDiscoveryRequests();
 }
@@ skipping 10 matching lines @@
       base::Bind(&BluetoothAdapterBlueZ::OnStartDiscovery,
                  weak_ptr_factory_.GetWeakPtr(), callback, error_callback),
       base::Bind(&BluetoothAdapterBlueZ::OnStartDiscoveryError,
                  weak_ptr_factory_.GetWeakPtr(), callback, error_callback));
 }
 
 void BluetoothAdapterBlueZ::OnPreSetDiscoveryFilterError(
     const base::Closure& callback,
     const DiscoverySessionErrorCallback& error_callback,
     UMABluetoothDiscoverySessionOutcome outcome) {
-  LOG(WARNING) << object_path_.value()
-               << ": Failed to pre set discovery filter.";
+  BLUETOOTH_LOG(ERROR) << object_path_.value()
+                       << ": Failed to pre set discovery filter.";
 
   // Failed to start discovery. This can only happen if the count is at 0.
   DCHECK_EQ(num_discovery_sessions_, 0);
   DCHECK(discovery_request_pending_);
   discovery_request_pending_ = false;
 
   error_callback.Run(outcome);
 
   // Try to add a new discovery session for each queued request.
   ProcessQueuedDiscoveryRequests();
 }
 
 void BluetoothAdapterBlueZ::OnSetDiscoveryFilter(
     const base::Closure& callback,
     const DiscoverySessionErrorCallback& error_callback) {
   // Report success on the original request and increment the count.
-  VLOG(1) << __func__;
+  BLUETOOTH_LOG(EVENT) << __func__;
   if (IsPresent()) {
     callback.Run();
   } else {
     error_callback.Run(UMABluetoothDiscoverySessionOutcome::ADAPTER_REMOVED);
   }
 }
 
 void BluetoothAdapterBlueZ::OnSetDiscoveryFilterError(
     const base::Closure& callback,
     const DiscoverySessionErrorCallback& error_callback,
     const std::string& error_name,
     const std::string& error_message) {
-  LOG(WARNING) << object_path_.value()
-               << ": Failed to set discovery filter: " << error_name << ": "
-               << error_message;
+  BLUETOOTH_LOG(ERROR) << object_path_.value()
+                       << ": Failed to set discovery filter: " << error_name
+                       << ": " << error_message;
 
   UMABluetoothDiscoverySessionOutcome outcome =
       TranslateDiscoveryErrorToUMA(error_name);
   if (outcome == UMABluetoothDiscoverySessionOutcome::FAILED) {
     // bluez/doc/adapter-api.txt says "Failed" is returned from
     // SetDiscoveryFilter when the controller doesn't support the requested
     // transport.
     outcome = UMABluetoothDiscoverySessionOutcome::
         BLUEZ_DBUS_FAILED_MAYBE_UNSUPPORTED_TRANSPORT;
   }
   error_callback.Run(outcome);
 
   // Try to add a new discovery session for each queued request.
   ProcessQueuedDiscoveryRequests();
 }
 
 void BluetoothAdapterBlueZ::ProcessQueuedDiscoveryRequests() {
   while (!discovery_request_queue_.empty()) {
-    VLOG(1) << "Process queued discovery request.";
+    BLUETOOTH_LOG(EVENT) << "Process queued discovery request.";
     DiscoveryParamTuple params = discovery_request_queue_.front();
     discovery_request_queue_.pop();
     AddDiscoverySession(std::get<0>(params), std::get<1>(params),
                         std::get<2>(params));
 
     // If the queued request resulted in a pending call, then let it
     // asynchonously process the remaining queued requests once the pending
     // call returns.
     if (discovery_request_pending_)
       return;
@@ skipping 51 matching lines @@
     const device::BluetoothGattService::ErrorCallback& error_callback,
     const std::string& /* error_name */,
     const std::string& /* error_message */) {
   RegisterApplication(callback, error_callback);
 }
 
 void BluetoothAdapterBlueZ::ServiceRecordErrorConnector(
     const ServiceRecordErrorCallback& error_callback,
     const std::string& error_name,
     const std::string& error_message) {
-  VLOG(1) << "Creating service record failed: error: " << error_name << " - "
-          << error_message;
+  BLUETOOTH_LOG(EVENT) << "Creating service record failed: error: "
+                       << error_name << " - " << error_message;
 
   BluetoothServiceRecordBlueZ::ErrorCode code =
       BluetoothServiceRecordBlueZ::ErrorCode::UNKNOWN;
   if (error_name == bluetooth_adapter::kErrorInvalidArguments) {
     code = BluetoothServiceRecordBlueZ::ErrorCode::ERROR_INVALID_ARGUMENTS;
   } else if (error_name == bluetooth_adapter::kErrorDoesNotExist) {
     code = BluetoothServiceRecordBlueZ::ErrorCode::ERROR_RECORD_DOES_NOT_EXIST;
   } else if (error_name == bluetooth_adapter::kErrorAlreadyExists) {
     code = BluetoothServiceRecordBlueZ::ErrorCode::ERROR_RECORD_ALREADY_EXISTS;
   } else if (error_name == bluetooth_adapter::kErrorNotReady) {
     code = BluetoothServiceRecordBlueZ::ErrorCode::ERROR_ADAPTER_NOT_READY;
   }
 
   error_callback.Run(code);
 }
 
 }  // namespace bluez