bluetooth: Add Bluetooth events to chrome://device-log/

device/bluetooth/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/bluetooth_adapter_bluez.h"
 
 #include <string>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/metrics/histogram.h"
 #include "base/sequenced_task_runner.h"
 #include "base/single_thread_task_runner.h"
 #include "base/thread_task_runner_handle.h"
 #include "build/build_config.h"
+#include "components/device_event_log/device_event_log.h"
 #include "device/bluetooth/bluetooth_adapter_profile_bluez.h"
 #include "device/bluetooth/bluetooth_advertisement_bluez.h"
 #include "device/bluetooth/bluetooth_audio_sink_bluez.h"
 #include "device/bluetooth/bluetooth_device.h"
 #include "device/bluetooth/bluetooth_device_bluez.h"
 #include "device/bluetooth/bluetooth_discovery_session_outcome.h"
 #include "device/bluetooth/bluetooth_pairing_bluez.h"
 #include "device/bluetooth/bluetooth_remote_gatt_characteristic_bluez.h"
 #include "device/bluetooth/bluetooth_remote_gatt_descriptor_bluez.h"
 #include "device/bluetooth/bluetooth_remote_gatt_service_bluez.h"
@@ skipping 92 matching lines @@
     delete it.second;
   profile_queues_.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";

[stevenjb, 2016/01/19 21:54:59]

Let's separate out these events from this CL and start with a couple of
important ones, then we can examine which of these actually belong in the event
log separately.

   bluez::BluezDBusManager::Get()
       ->GetBluetoothAgentManagerClient()
       ->UnregisterAgent(dbus::ObjectPath(kAgentPath),
                         base::Bind(&base::DoNothing),
                         base::Bind(&OnUnregisterAgentError));
 
   agent_.reset();
   dbus_is_shutdown_ = true;
 }
 
@@ skipping 14 matching lines @@
   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();
 
   if (!object_paths.empty()) {
-    VLOG(1) << object_paths.size() << " Bluetooth adapter(s) available.";
+    BLUETOOTH_LOG(EVENT) << object_paths.size()
+                         << " Bluetooth adapter(s) available.";
     SetAdapter(object_paths[0]);
   }
 }
 
 BluetoothAdapterBlueZ::~BluetoothAdapterBlueZ() {
   Shutdown();
 }
 
 std::string BluetoothAdapterBlueZ::GetAddress() const {
   if (!IsPresent())
@@ skipping 116 matching lines @@
 
   return properties->discovering.value();
 }
 
 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(EVENT) << 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(EVENT) << 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::RegisterAudioSink(
     const BluetoothAudioSink::Options& options,
     const device::BluetoothAdapter::AcquiredCallback& callback,
     const BluetoothAudioSink::ErrorCallback& error_callback) {
-  VLOG(1) << "Registering audio sink";
+  BLUETOOTH_LOG(EVENT) << "Registering audio sink";
   if (!this->IsPresent()) {
     error_callback.Run(BluetoothAudioSink::ERROR_INVALID_ADAPTER);
     return;
   }
   scoped_refptr<BluetoothAudioSinkBlueZ> audio_sink(
       new BluetoothAudioSinkBlueZ(this));
   audio_sink->Register(options,
                        base::Bind(&BluetoothAdapterBlueZ::OnRegisterAudioSink,
                                   weak_ptr_factory_.GetWeakPtr(), callback,
                                   error_callback, audio_sink),
@@ skipping 102 matching lines @@
 
   bluez::BluetoothDeviceClient::Properties* properties =
       bluez::BluezDBusManager::Get()->GetBluetoothDeviceClient()->GetProperties(
           object_path);
 
   if (property_name == properties->address.name()) {
     for (DevicesMap::iterator 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();
         scoped_ptr<BluetoothDevice> scoped_device =
             devices_.take_and_erase(iter);
         ignore_result(scoped_device.release());
 
         DCHECK(devices_.find(device_bluez->GetAddress()) == devices_.end());
         devices_.set(device_bluez->GetAddress(),
                      scoped_ptr<BluetoothDevice>(device_bluez));
         NotifyDeviceAddressChanged(device_bluez, old_address);
         break;
       }
@@ skipping 57 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) << "Release";
   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;
   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;
 }
 
 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;
 }
 
 void BluetoothAdapterBlueZ::OnRegisterAudioSink(
     const device::BluetoothAdapter::AcquiredCallback& callback,
     const device::BluetoothAudioSink::ErrorCallback& error_callback,
     scoped_refptr<BluetoothAudioSink> audio_sink) {
   if (!IsPresent()) {
-    VLOG(1) << "Failed to register audio sink, adapter not present";
+    BLUETOOTH_LOG(ERROR) << "Failed to register audio sink, "
+                         << "adapter not present";
     error_callback.Run(BluetoothAudioSink::ERROR_INVALID_ADAPTER);
     return;
   }
   DCHECK(audio_sink.get());
   callback.Run(audio_sink);
 }
 
 BluetoothDeviceBlueZ* BluetoothAdapterBlueZ::GetDeviceWithPath(
     const dbus::ObjectPath& object_path) {
   if (!IsPresent())
@@ skipping 31 matching lines @@
     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(EVENT) << "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()));
 
   SetDefaultAdapterName();
@@ skipping 47 matching lines @@
   }
 #elif defined(OS_LINUX)
   alias = "ChromeLinux";
 #endif
 
   SetName(alias, base::Bind(&base::DoNothing), base::Bind(&base::DoNothing));
 }
 
 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())
     PoweredChanged(false);
@@ skipping 22 matching lines @@
 }
 
 void BluetoothAdapterBlueZ::DiscoverableChanged(bool discoverable) {
   FOR_EACH_OBSERVER(BluetoothAdapter::Observer, observers_,
                     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(EVENT) << "Marking sessions as inactive.";
     num_discovery_sessions_ = 0;
     MarkDiscoverySessionsAsInactive();
   }
   FOR_EACH_OBSERVER(BluetoothAdapter::Observer, observers_,
                     AdapterDiscoveringChanged(this, discovering));
 }
 
 void BluetoothAdapterBlueZ::PresentChanged(bool present) {
   FOR_EACH_OBSERVER(BluetoothAdapter::Observer, observers_,
                     AdapterPresentChanged(this, present));
@@ skipping 132 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(ERROR) << "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();
   profile->RemoveDelegate(
       device_path, base::Bind(&BluetoothAdapterBlueZ::RemoveProfile,
                               weak_ptr_factory_.GetWeakPtr(), profile->uuid()));
 }
 
 void BluetoothAdapterBlueZ::RemoveProfile(const BluetoothUUID& uuid) {
-  VLOG(2) << "Remove Profile: " << uuid.canonical_value();
+  BLUETOOTH_LOG(EVENT) << "Remove Profile: " << uuid.canonical_value();
 
   if (profiles_.find(uuid) != profiles_.end()) {
     delete profiles_[uuid];
     profiles_.erase(uuid);
   }
 }
 
 void BluetoothAdapterBlueZ::OnRegisterProfile(
     const BluetoothUUID& uuid,
     scoped_ptr<BluetoothAdapterProfileBlueZ> profile) {
@@ skipping 24 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(DEBUG) << __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(EVENT)
+        << "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(DEBUG) << __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(EVENT) << "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(EVENT) << "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 71 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(DEBUG) << __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);
   }
 
@@ skipping 13 matching lines @@
   // 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(EVENT)
+        << "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(DEBUG) << __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();
@@ skipping 47 matching lines @@
   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(DEBUG) << __func__;
   if (IsPresent()) {
     callback.Run();
   } else {
     error_callback.Run(UMABluetoothDiscoverySessionOutcome::ADAPTER_REMOVED);
   }
 }
 
 void BluetoothAdapterBlueZ::OnSetDiscoveryFilterError(
     const base::Closure& callback,
     const DiscoverySessionErrorCallback& error_callback,
@@ skipping 13 matching lines @@
         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;
   }
 }
 
 }  // namespace bluez