Remove Debug restriction on Bluetooth log messages

device/bluetooth/bluetooth_adapter_chromeos.cc

 // Copyright (c) 2012 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_chromeos.h"
 
 #include <string>
 
 #include "base/bind.h"
 #include "base/logging.h"
@@ skipping 116 matching lines @@
     const ErrorCallback& error_callback) {
   DBusThreadManager::Get()->GetBluetoothOutOfBandClient()->
       ReadLocalData(object_path_,
           base::Bind(&BluetoothAdapterChromeOS::OnReadLocalData,
               weak_ptr_factory_.GetWeakPtr(),
               callback,
               error_callback));
 }
 
 void BluetoothAdapterChromeOS::TrackDefaultAdapter() {
-  DVLOG(1) << "Tracking default adapter";
+  VLOG(1) << "Tracking default adapter";
   track_default_ = true;
   DBusThreadManager::Get()->GetBluetoothManagerClient()->
       DefaultAdapter(base::Bind(&BluetoothAdapterChromeOS::AdapterCallback,
                                 weak_ptr_factory_.GetWeakPtr()));
 }
 
 void BluetoothAdapterChromeOS::FindAdapter(const std::string& address) {
-  DVLOG(1) << "Using adapter " << address;
+  VLOG(1) << "Using adapter " << address;
   track_default_ = false;
   DBusThreadManager::Get()->GetBluetoothManagerClient()->
       FindAdapter(address,
                   base::Bind(&BluetoothAdapterChromeOS::AdapterCallback,
                              weak_ptr_factory_.GetWeakPtr()));
 }
 
 void BluetoothAdapterChromeOS::AdapterCallback(
     const dbus::ObjectPath& adapter_path,
     bool success) {
@@ skipping 12 matching lines @@
 
 void BluetoothAdapterChromeOS::AdapterRemoved(
     const dbus::ObjectPath& adapter_path) {
   if (adapter_path == object_path_)
     RemoveAdapter();
 }
 
 void BluetoothAdapterChromeOS::ChangeAdapter(
     const dbus::ObjectPath& adapter_path) {
   if (object_path_.value().empty()) {
-    DVLOG(1) << "Adapter path initialized to " << adapter_path.value();
+    VLOG(1) << "Adapter path initialized to " << adapter_path.value();
   } else if (object_path_.value() != adapter_path.value()) {
-    DVLOG(1) << "Adapter path changed from " << object_path_.value()
-             << " to " << adapter_path.value();
+    VLOG(1) << "Adapter path changed from " << object_path_.value()
+            << " to " << adapter_path.value();
 
     RemoveAdapter();
   } else {
-    DVLOG(1) << "Adapter address updated";
+    VLOG(1) << "Adapter address updated";
   }
 
   object_path_ = adapter_path;
 
   // Update properties to their new values.
   BluetoothAdapterClient::Properties* properties =
       DBusThreadManager::Get()->GetBluetoothAdapterClient()->
       GetProperties(object_path_);
 
   address_ = properties->address.value();
   name_ = properties->name.value();
 
   // Delay announcing a new adapter until we have an address.
   if (address_.empty()) {
-    DVLOG(1) << "Adapter address not yet known";
+    VLOG(1) << "Adapter address not yet known";
     return;
   }
 
   PoweredChanged(properties->powered.value());
   DiscoveringChanged(properties->discovering.value());
   DevicesChanged(properties->devices.value());
 
   FOR_EACH_OBSERVER(BluetoothAdapter::Observer, observers_,
                     AdapterPresentChanged(this, true));
 }
 
 void BluetoothAdapterChromeOS::RemoveAdapter() {
   const bool adapter_was_present = IsPresent();
 
-  DVLOG(1) << "Adapter lost.";
+  VLOG(1) << "Adapter lost.";
   PoweredChanged(false);
   DiscoveringChanged(false);
   ClearDevices();
 
   object_path_ = dbus::ObjectPath("");
   address_.clear();
   name_.clear();
 
   if (adapter_was_present)
     FOR_EACH_OBSERVER(BluetoothAdapter::Observer, observers_,
@@ skipping 19 matching lines @@
                     AdapterPoweredChanged(this, powered_));
 }
 
 void BluetoothAdapterChromeOS::OnStartDiscovery(
     const base::Closure& callback,
     const ErrorCallback& error_callback,
     const dbus::ObjectPath& adapter_path,
     bool success) {
   if (success) {
     if (discovering_count_++ == 0) {
-      DVLOG(1) << object_path_.value() << ": started discovery.";
+      VLOG(1) << object_path_.value() << ": started discovery.";
 
       // Clear devices found in previous discovery attempts
       ClearDiscoveredDevices();
 
       FOR_EACH_OBSERVER(BluetoothAdapter::Observer, observers_,
                         AdapterDiscoveringChanged(this, true));
     }
 
     callback.Run();
   } else {
     error_callback.Run();
   }
 }
 
 void BluetoothAdapterChromeOS::OnStopDiscovery(
     const base::Closure& callback,
     const ErrorCallback& error_callback,
     const dbus::ObjectPath& adapter_path,
     bool success) {
   if (success) {
     if (--discovering_count_ == 0) {
-      DVLOG(1) << object_path_.value() << ": stopped discovery.";
+      VLOG(1) << object_path_.value() << ": stopped discovery.";
 
       FOR_EACH_OBSERVER(BluetoothAdapter::Observer, observers_,
                         AdapterDiscoveringChanged(this, false));
     } else if (discovering_count_ < 0) {
       LOG(WARNING) << adapter_path.value() << ": call to StopDiscovering "
                    << "without matching StartDiscovering.";
       error_callback.Run();
       return;
     }
 
@@ skipping 85 matching lines @@
   const bool update_device = (iter != devices_.end());
   if (update_device) {
     device = static_cast<BluetoothDeviceChromeOS*>(iter->second);
   } else {
     device = BluetoothDeviceChromeOS::Create(this);
     devices_[address] = device;
   }
 
   const bool was_paired = device->IsPaired();
   if (!was_paired) {
-    DVLOG(1) << "Assigned object path " << device_path.value() << " to device "
-             << address;
+    VLOG(1) << "Assigned object path " << device_path.value() << " to device "
+            << address;
     device->SetObjectPath(device_path);
   }
   device->Update(properties, true);
 
   if (update_device) {
     FOR_EACH_OBSERVER(BluetoothAdapter::Observer, observers_,
                       DeviceChanged(this, device));
   } else {
     FOR_EACH_OBSERVER(BluetoothAdapter::Observer, observers_,
                       DeviceAdded(this, device));
@@ skipping 38 matching lines @@
     if (device->object_path_ != device_path)
       continue;
 
     // DeviceRemoved can also be called to indicate a device that is visible
     // during discovery has disconnected, but it is still visible to the
     // adapter, so don't remove in that case and only clear the object path.
     if (!device->IsVisible()) {
       FOR_EACH_OBSERVER(BluetoothAdapter::Observer, observers_,
                         DeviceRemoved(this, device));
 
-      DVLOG(1) << "Removed device " << device->address();
+      VLOG(1) << "Removed device " << device->address();
 
       delete device;
       devices_.erase(temp);
     } else {
-      DVLOG(1) << "Removed object path from device " << device->address();
+      VLOG(1) << "Removed object path from device " << device->address();
       device->RemoveObjectPath();
 
       FOR_EACH_OBSERVER(BluetoothAdapter::Observer, observers_,
                         DeviceChanged(this, device));
     }
   }
 }
 
 void BluetoothAdapterChromeOS::DevicesChanged(
     const std::vector<dbus::ObjectPath>& devices) {
@@ skipping 32 matching lines @@
   BluetoothDeviceChromeOS* device;
   DevicesMap::iterator iter = devices_.find(address);
   const bool update_device = (iter != devices_.end());
   if (update_device) {
     device = static_cast<BluetoothDeviceChromeOS*>(iter->second);
   } else {
     device = BluetoothDeviceChromeOS::Create(this);
     devices_[address] = device;
   }
 
-  DVLOG(1) << "Device " << address << " is visible to the adapter";
+  VLOG(1) << "Device " << address << " is visible to the adapter";
   device->SetVisible(true);
   device->Update(&properties, false);
 
   if (update_device) {
     FOR_EACH_OBSERVER(BluetoothAdapter::Observer, observers_,
                       DeviceChanged(this, device));
   } else {
     FOR_EACH_OBSERVER(BluetoothAdapter::Observer, observers_,
                       DeviceAdded(this, device));
   }
@@ skipping 12 matching lines @@
   BluetoothDeviceChromeOS* device =
       static_cast<BluetoothDeviceChromeOS*>(iter->second);
 
   // DeviceDisappeared can also be called to indicate that a device we've
   // paired with is no longer visible to the adapter, so don't remove
   // in that case and only clear the visible flag.
   if (!device->IsPaired()) {
     FOR_EACH_OBSERVER(BluetoothAdapter::Observer, observers_,
                       DeviceRemoved(this, device));
 
-    DVLOG(1) << "Discovered device " << device->address()
+    VLOG(1) << "Discovered device " << device->address()
              << " is no longer visible to the adapter";
 
     delete device;
     devices_.erase(iter);
   } else {
-    DVLOG(1) << "Paired device " << device->address()
-             << " is no longer visible to the adapter";
+    VLOG(1) << "Paired device " << device->address()
+            << " is no longer visible to the adapter";
     device->SetVisible(false);
 
     FOR_EACH_OBSERVER(BluetoothAdapter::Observer, observers_,
                       DeviceChanged(this, device));
   }
 }
 
 }  // namespace chromeos