Remove Debug restriction on Bluetooth log messages

chrome/browser/ui/webui/options/chromeos/bluetooth_options_handler.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 "chrome/browser/ui/webui/options/chromeos/bluetooth_options_handler.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/callback.h"
 #include "base/command_line.h"
@@ skipping 207 matching lines @@
   bool bluetooth_enabled;
   args->GetBoolean(0, &bluetooth_enabled);
 
   adapter_->SetPowered(bluetooth_enabled,
                        base::Bind(&base::DoNothing),
                        base::Bind(&BluetoothOptionsHandler::EnableChangeError,
                                   weak_ptr_factory_.GetWeakPtr()));
 }
 
 void BluetoothOptionsHandler::EnableChangeError() {
-  DVLOG(1) << "Failed to change power state.";
+  VLOG(1) << "Failed to change power state.";
   ReportError("bluetoothChangePowerFailed", std::string());
 }
 
 void BluetoothOptionsHandler::FindDevicesCallback(
     const ListValue* args) {
   if (!discovering_) {
     discovering_ = true;
     adapter_->StartDiscovering(
         base::Bind(&base::DoNothing),
         base::Bind(&BluetoothOptionsHandler::FindDevicesError,
                    weak_ptr_factory_.GetWeakPtr()));
   }
 }
 
 void BluetoothOptionsHandler::FindDevicesError() {
-  DVLOG(1) << "Failed to start discovery.";
+  VLOG(1) << "Failed to start discovery.";
   ReportError("bluetoothStartDiscoveryFailed", std::string());
 }
 
 void BluetoothOptionsHandler::UpdateDeviceCallback(
     const ListValue* args) {
   std::string address;
   args->GetString(kUpdateDeviceAddressIndex, &address);
 
   device::BluetoothDevice* device = adapter_->GetDevice(address);
   if (!device)
     return;
 
   std::string command;
   args->GetString(kUpdateDeviceCommandIndex, &command);
 
   if (command == kConnectCommand) {
     int size = args->GetSize();
     if (size > kUpdateDeviceAuthTokenIndex) {
       // PIN code or Passkey entry during the pairing process.
       std::string auth_token;
       args->GetString(kUpdateDeviceAuthTokenIndex, &auth_token);
 
       if (device->ExpectingPinCode()) {
         DeviceConnecting(device);
         // PIN Code is an array of 1 to 16 8-bit bytes, the usual
         // interpretation, and the one shared by BlueZ, is a UTF-8 string
         // of as many characters that will fit in that space, thus we
         // can use the auth token from JavaScript unmodified.
-        DVLOG(1) << "PIN Code supplied: " << address << ": " << auth_token;
+        VLOG(1) << "PIN Code supplied: " << address << ": " << auth_token;
         device->SetPinCode(auth_token);
       } else if (device->ExpectingPasskey()) {
         DeviceConnecting(device);
         // Passkey is a numeric in the range 0-999999, in this case the
         // JavaScript code should have ensured the auth token string only
         // contains digits so a simple conversion is sufficient. In the
         // failure case, just use 0 since that's the most likely Passkey
         // anyway, and if it's refused the device will request a new one.
         unsigned passkey = 0;
         base::StringToUint(auth_token, &passkey);
 
-        DVLOG(1) << "Passkey supplied: " << address << ": " << passkey;
+        VLOG(1) << "Passkey supplied: " << address << ": " << passkey;
         device->SetPasskey(passkey);
       } else {
         LOG(WARNING) << "Auth token supplied after pairing ended: " << address
                      << ": " << auth_token;
       }
     } else {
       // Connection request.
-      DVLOG(1) << "Connect: " << address;
+      VLOG(1) << "Connect: " << address;
       device->Connect(
           this,
           base::Bind(&base::DoNothing),
           base::Bind(&BluetoothOptionsHandler::ConnectError,
                      weak_ptr_factory_.GetWeakPtr(),
                      device->address()));
     }
   } else if (command == kCancelCommand) {
     // Cancel pairing.
-    DVLOG(1) << "Cancel pairing: " << address;
+    VLOG(1) << "Cancel pairing: " << address;
     device->CancelPairing();
   } else if (command == kAcceptCommand) {
     // Confirm displayed Passkey.
-    DVLOG(1) << "Confirm pairing: " << address;
+    VLOG(1) << "Confirm pairing: " << address;
     device->ConfirmPairing();
   } else if (command == kRejectCommand) {
     // Reject displayed Passkey.
-    DVLOG(1) << "Reject pairing: " << address;
+    VLOG(1) << "Reject pairing: " << address;
     device->RejectPairing();
   } else if (command == kDisconnectCommand) {
     // Disconnect from device.
-    DVLOG(1) << "Disconnect device: " << address;
+    VLOG(1) << "Disconnect device: " << address;
     device->Disconnect(
         base::Bind(&base::DoNothing),
         base::Bind(&BluetoothOptionsHandler::DisconnectError,
                    weak_ptr_factory_.GetWeakPtr(),
                    device->address()));
   } else if (command == kForgetCommand) {
     // Disconnect from device and delete pairing information.
-    DVLOG(1) << "Forget device: " << address;
+    VLOG(1) << "Forget device: " << address;
     device->Forget(base::Bind(&BluetoothOptionsHandler::ForgetError,
                               weak_ptr_factory_.GetWeakPtr(),
                               device->address()));
   } else {
     LOG(WARNING) << "Unknown updateBluetoothDevice command: " << command;
   }
 }
 
 void BluetoothOptionsHandler::ConnectError(
     const std::string& address,
     device::BluetoothDevice::ConnectErrorCode error_code) {
   const char* error_name = NULL;
 
-  DVLOG(1) << "Failed to connect to device: " << address;
+  VLOG(1) << "Failed to connect to device: " << address;
   switch (error_code) {
     case device::BluetoothDevice::ERROR_UNKNOWN:
       error_name = "bluetoothConnectUnknownError";
       break;
     case device::BluetoothDevice::ERROR_INPROGRESS:
       error_name = "bluetoothConnectInProgress";
       break;
     case device::BluetoothDevice::ERROR_FAILED:
       error_name = "bluetoothConnectFailed";
       break;
@@ skipping 12 matching lines @@
     case device::BluetoothDevice::ERROR_UNSUPPORTED_DEVICE:
       error_name = "bluetoothConnectUnsupportedDevice";
       break;
   }
   // Report an error only if there's an error to report.
   if (error_name)
     ReportError(error_name, address);
 }
 
 void BluetoothOptionsHandler::DisconnectError(const std::string& address) {
-  DVLOG(1) << "Failed to disconnect from device: " << address;
+  VLOG(1) << "Failed to disconnect from device: " << address;
   ReportError("bluetoothDisconnectFailed", address);
 }
 
 void BluetoothOptionsHandler::ForgetError(const std::string& address) {
-  DVLOG(1) << "Failed to disconnect and unpair device: " << address;
+  VLOG(1) << "Failed to disconnect and unpair device: " << address;
   ReportError("bluetoothForgetFailed", address);
 }
 
 void BluetoothOptionsHandler::StopDiscoveryCallback(
     const ListValue* args) {
   if (discovering_) {
     adapter_->StopDiscovering(
         base::Bind(&base::DoNothing),
         base::Bind(&BluetoothOptionsHandler::StopDiscoveryError,
                    weak_ptr_factory_.GetWeakPtr()));
     discovering_ = false;
   }
 }
 
 void BluetoothOptionsHandler::StopDiscoveryError() {
-  DVLOG(1) << "Failed to stop discovery.";
+  VLOG(1) << "Failed to stop discovery.";
   ReportError("bluetoothStopDiscoveryFailed", std::string());
 }
 
 void BluetoothOptionsHandler::GetPairedDevicesCallback(
     const ListValue* args) {
   device::BluetoothAdapter::DeviceList devices = adapter_->GetDevices();
 
   for (device::BluetoothAdapter::DeviceList::iterator iter = devices.begin();
        iter != devices.end(); ++iter)
     SendDeviceNotification(*iter, NULL);
@@ skipping 96 matching lines @@
 void BluetoothOptionsHandler::DeviceConnecting(
     device::BluetoothDevice* device) {
   DCHECK(device);
   DictionaryValue params;
   params.SetString("pairing", kStartConnecting);
   SendDeviceNotification(device, &params);
 }
 
 }  // namespace options
 }  // namespace chromeos