Remove Debug restriction on Bluetooth log messages

device/bluetooth/bluetooth_device_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_device_chromeos.h"
 
 #include <map>
 #include <string>
 #include <vector>
 
@@ skipping 151 matching lines @@
 
     dbus::Bus* system_bus = DBusThreadManager::Get()->GetSystemBus();
     if (system_bus) {
       agent_.reset(BluetoothAgentServiceProvider::Create(system_bus,
                                                          agent_path,
                                                          this));
     } else {
       agent_.reset(NULL);
     }
 
-    DVLOG(1) << "Pairing: " << address_;
+    VLOG(1) << "Pairing: " << address_;
     DBusThreadManager::Get()->GetBluetoothAdapterClient()->
         CreatePairedDevice(
             adapter_->object_path_,
             address_,
             agent_path,
             bluetooth_agent::kDisplayYesNoCapability,
             base::Bind(&BluetoothDeviceChromeOS::OnCreateDevice,
                        weak_ptr_factory_.GetWeakPtr(),
                        wrapped_callback,
                        wrapped_error_callback),
@@ skipping 181 matching lines @@
     // spec refers to this as bonded. Use the spec name for our interface.
     bonded_ = properties->paired.value();
     connected_ = properties->connected.value();
   }
 }
 
 void BluetoothDeviceChromeOS::OnCreateDevice(
     const base::Closure& callback,
     const ConnectErrorCallback& error_callback,
     const dbus::ObjectPath& device_path) {
-  DVLOG(1) << "Connection successful: " << device_path.value();
+  VLOG(1) << "Connection successful: " << device_path.value();
   if (object_path_.value().empty()) {
     object_path_ = device_path;
   } else {
     LOG_IF(WARNING, object_path_ != device_path)
         << "Conflicting device paths for objects, result gave: "
         << device_path.value() << " but signal gave: "
         << object_path_.value();
   }
 
   // Mark the device trusted so it can connect to us automatically, and
@@ skipping 91 matching lines @@
       hid_reconnect_initiate =
           hid_reconnect_initiate && (*it)->hid_reconnect_initiate();
     }
   }
   // The Bluetooth HID spec states that if HIDNormallyConnectable or
   // HIDReconnectInitiate are not present in a HID profile, the value is false.
   // Nevertheless, a device with both properties in false can't reconnect to the
   // adapter and can't be reconnected from the adapter. To avoid problems with
   // devices that don't export this properties we asume they are connectable.
   connectable_ = hid_normally_connectable || !hid_reconnect_initiate;
-  DVLOG(1) << "ServiceRecordsChanged for " << address_
-           << ": connectable = " << connectable_;
+  VLOG(1) << "ServiceRecordsChanged for " << address_
+          << ": connectable = " << connectable_;
 }
 
 void BluetoothDeviceChromeOS::OnSetTrusted(bool success) {
   LOG_IF(WARNING, !success) << "Failed to set device as trusted: " << address_;
 }
 
 void BluetoothDeviceChromeOS::OnInitialGetServiceRecords(
     const base::Closure& callback,
     const ConnectErrorCallback& error_callback,
     const ServiceRecordList& list) {
@@ skipping 94 matching lines @@
   // directly as it has not been called by any of the OnConnect callbacks.
   // This is safe because OnIntrospect and OnConnect run on the same thread.
   connecting_applications_counter_--;
   if (connecting_applications_counter_ == -1)
     callback.Run();
 }
 
 void BluetoothDeviceChromeOS::OnConnect(const base::Closure& callback,
                                         const std::string& interface_name,
                                         const dbus::ObjectPath& device_path) {
-  DVLOG(1) << "Application connection successful: " << device_path.value()
-           << ": " << interface_name;
+  VLOG(1) << "Application connection successful: " << device_path.value()
+          << ": " << interface_name;
 
   connecting_applications_counter_--;
   // |callback| should only be called once, meaning it cannot be called before
   // all requests have been started.  The extra decrement after all requests
   // have been started, and the check for -1 instead of 0 below, insure only a
   // single call to |callback| will occur (provided OnConnect and OnIntrospect
   // run on the same thread, which is true).
   if (connecting_applications_counter_ == -1) {
     connecting_applications_counter_ = 0;
     callback.Run();
@@ skipping 28 matching lines @@
   error_callback.Run(error_code);
 }
 
 void BluetoothDeviceChromeOS::DisconnectCallback(
     const base::Closure& callback,
     const ErrorCallback& error_callback,
     const dbus::ObjectPath& device_path,
     bool success) {
   DCHECK(device_path == object_path_);
   if (success) {
-    DVLOG(1) << "Disconnection successful: " << address_;
+    VLOG(1) << "Disconnection successful: " << address_;
     callback.Run();
   } else {
     if (connected_)  {
       LOG(WARNING) << "Disconnection failed: " << address_;
       error_callback.Run();
     } else {
-      DVLOG(1) << "Disconnection failed on a already disconnected device: "
-               << address_;
+      VLOG(1) << "Disconnection failed on a already disconnected device: "
+              << address_;
       callback.Run();
     }
   }
 }
 
 void BluetoothDeviceChromeOS::ForgetCallback(
     const ErrorCallback& error_callback,
     const dbus::ObjectPath& adapter_path,
     bool success) {
   // It's quite normal that this path never gets called on success; we use a
@@ skipping 67 matching lines @@
     error_callback.Run();
 }
 
 void BluetoothDeviceChromeOS::DisconnectRequested(
     const dbus::ObjectPath& object_path) {
   DCHECK(object_path == object_path_);
 }
 
 void BluetoothDeviceChromeOS::Release() {
   DCHECK(agent_.get());
-  DVLOG(1) << "Release: " << address_;
+  VLOG(1) << "Release: " << address_;
 
   DCHECK(pairing_delegate_);
   pairing_delegate_->DismissDisplayOrConfirm();
   pairing_delegate_ = NULL;
 
   pincode_callback_.Reset();
   passkey_callback_.Reset();
   confirmation_callback_.Reset();
 
   agent_.reset();
 }
 
 void BluetoothDeviceChromeOS::RequestPinCode(
     const dbus::ObjectPath& device_path,
     const PinCodeCallback& callback) {
   DCHECK(agent_.get());
-  DVLOG(1) << "RequestPinCode: " << device_path.value();
+  VLOG(1) << "RequestPinCode: " << device_path.value();
 
   DCHECK(pairing_delegate_);
   DCHECK(pincode_callback_.is_null());
   pincode_callback_ = callback;
   pairing_delegate_->RequestPinCode(this);
 }
 
 void BluetoothDeviceChromeOS::RequestPasskey(
     const dbus::ObjectPath& device_path,
     const PasskeyCallback& callback) {
   DCHECK(agent_.get());
   DCHECK(device_path == object_path_);
-  DVLOG(1) << "RequestPasskey: " << device_path.value();
+  VLOG(1) << "RequestPasskey: " << device_path.value();
 
   DCHECK(pairing_delegate_);
   DCHECK(passkey_callback_.is_null());
   passkey_callback_ = callback;
   pairing_delegate_->RequestPasskey(this);
 }
 
 void BluetoothDeviceChromeOS::DisplayPinCode(
     const dbus::ObjectPath& device_path,
     const std::string& pincode) {
   DCHECK(agent_.get());
   DCHECK(device_path == object_path_);
-  DVLOG(1) << "DisplayPinCode: " << device_path.value() << " " << pincode;
+  VLOG(1) << "DisplayPinCode: " << device_path.value() << " " << pincode;
 
   DCHECK(pairing_delegate_);
   pairing_delegate_->DisplayPinCode(this, pincode);
 }
 
 void BluetoothDeviceChromeOS::DisplayPasskey(
     const dbus::ObjectPath& device_path,
     uint32 passkey) {
   DCHECK(agent_.get());
   DCHECK(device_path == object_path_);
-  DVLOG(1) << "DisplayPasskey: " << device_path.value() << " " << passkey;
+  VLOG(1) << "DisplayPasskey: " << device_path.value() << " " << passkey;
 
   DCHECK(pairing_delegate_);
   pairing_delegate_->DisplayPasskey(this, passkey);
 }
 
 void BluetoothDeviceChromeOS::RequestConfirmation(
     const dbus::ObjectPath& device_path,
     uint32 passkey,
     const ConfirmationCallback& callback) {
   DCHECK(agent_.get());
   DCHECK(device_path == object_path_);
-  DVLOG(1) << "RequestConfirmation: " << device_path.value() << " " << passkey;
+  VLOG(1) << "RequestConfirmation: " << device_path.value() << " " << passkey;
 
   DCHECK(pairing_delegate_);
   DCHECK(confirmation_callback_.is_null());
   confirmation_callback_ = callback;
   pairing_delegate_->ConfirmPasskey(this, passkey);
 }
 
 void BluetoothDeviceChromeOS::Authorize(const dbus::ObjectPath& device_path,
                                         const std::string& uuid,
                                         const ConfirmationCallback& callback) {
   DCHECK(agent_.get());
   DCHECK(device_path == object_path_);
   LOG(WARNING) << "Rejected authorization for service: " << uuid
                << " requested from device: " << device_path.value();
   callback.Run(REJECTED);
 }
 
 void BluetoothDeviceChromeOS::ConfirmModeChange(
     Mode mode,
     const ConfirmationCallback& callback) {
   DCHECK(agent_.get());
   LOG(WARNING) << "Rejected adapter-level mode change: " << mode
                << " made on agent for device: " << address_;
   callback.Run(REJECTED);
 }
 
 void BluetoothDeviceChromeOS::Cancel() {
   DCHECK(agent_.get());
-  DVLOG(1) << "Cancel: " << address_;
+  VLOG(1) << "Cancel: " << address_;
 
   DCHECK(pairing_delegate_);
   pairing_delegate_->DismissDisplayOrConfirm();
 }
 
 
 // static
 BluetoothDeviceChromeOS* BluetoothDeviceChromeOS::Create(
     BluetoothAdapterChromeOS* adapter) {
   return new BluetoothDeviceChromeOS(adapter);
 }
 
 }  // namespace chromeos