Remove implicit HANDLE conversions from device.

device/bluetooth/bluetooth_task_manager_win.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_task_manager_win.h"
 
 #include <winsock2.h>
 
 #include <string>
 
@@ skipping 273 matching lines @@
       BluetoothTaskManagerWin::Observer, observers_, DevicesPolled(*devices));
 }
 
 void BluetoothTaskManagerWin::PollAdapter() {
   DCHECK(bluetooth_task_runner_->RunsTasksOnCurrentThread());
 
   // Skips updating the adapter info if the adapter is in discovery mode.
   if (!discovering_) {
     const BLUETOOTH_FIND_RADIO_PARAMS adapter_param =
         { sizeof(BLUETOOTH_FIND_RADIO_PARAMS) };
-    if (adapter_handle_)
+    if (adapter_handle_.IsValid())
       adapter_handle_.Close();
     HANDLE temp_adapter_handle;
     HBLUETOOTH_RADIO_FIND handle = BluetoothFindFirstRadio(
         &adapter_param, &temp_adapter_handle);
 
     if (handle) {
       adapter_handle_.Set(temp_adapter_handle);
       GetKnownDevices();
       BluetoothFindRadioClose(handle);
     }
 
     PostAdapterStateToUi();
   }
 
   // Re-poll.
   bluetooth_task_runner_->PostDelayedTask(
       FROM_HERE,
       base::Bind(&BluetoothTaskManagerWin::PollAdapter,
                  this),
       base::TimeDelta::FromMilliseconds(kPollIntervalMs));
 }
 
 void BluetoothTaskManagerWin::PostAdapterStateToUi() {
   DCHECK(bluetooth_task_runner_->RunsTasksOnCurrentThread());
   AdapterState* state = new AdapterState();
-  GetAdapterState(adapter_handle_, state);
+  GetAdapterState(adapter_handle_.Get(), state);
   ui_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&BluetoothTaskManagerWin::OnAdapterStateChanged,
                  this,
                  base::Owned(state)));
 }
 
 void BluetoothTaskManagerWin::SetPowered(
     bool powered,
     const base::Closure& callback,
     const BluetoothAdapter::ErrorCallback& error_callback) {
   DCHECK(bluetooth_task_runner_->RunsTasksOnCurrentThread());
   bool success = false;
-  if (adapter_handle_) {
+  if (adapter_handle_.IsValid()) {
     if (!powered)
-      BluetoothEnableDiscovery(adapter_handle_, false);
-    success = !!BluetoothEnableIncomingConnections(adapter_handle_, powered);
+      BluetoothEnableDiscovery(adapter_handle_.Get(), false);
+    success =
+        !!BluetoothEnableIncomingConnections(adapter_handle_.Get(), powered);
   }
 
   if (success) {
     PostAdapterStateToUi();
     ui_task_runner_->PostTask(FROM_HERE, callback);
   } else {
     ui_task_runner_->PostTask(FROM_HERE, error_callback);
   }
 }
 
 void BluetoothTaskManagerWin::StartDiscovery() {
   DCHECK(bluetooth_task_runner_->RunsTasksOnCurrentThread());
   ui_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&BluetoothTaskManagerWin::OnDiscoveryStarted,
                  this,
-                 !!adapter_handle_));
-  if (!adapter_handle_)
+                 adapter_handle_.IsValid()));
+  if (!adapter_handle_.IsValid())
     return;
   discovering_ = true;
 
   DiscoverDevices(1);
 }
 
 void BluetoothTaskManagerWin::StopDiscovery() {
   DCHECK(bluetooth_task_runner_->RunsTasksOnCurrentThread());
   discovering_ = false;
   ui_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&BluetoothTaskManagerWin::OnDiscoveryStopped, this));
 }
 
 void BluetoothTaskManagerWin::DiscoverDevices(int timeout_multiplier) {
   DCHECK(bluetooth_task_runner_->RunsTasksOnCurrentThread());
-  if (!discovering_ || !adapter_handle_) {
+  if (!discovering_ || !adapter_handle_.IsValid()) {
     ui_task_runner_->PostTask(
         FROM_HERE,
         base::Bind(&BluetoothTaskManagerWin::OnDiscoveryStopped, this));
     return;
   }
 
   scoped_ptr<ScopedVector<DeviceState> > device_list(
       new ScopedVector<DeviceState>());
   if (SearchDevices(timeout_multiplier, false, device_list.get())) {
     ui_task_runner_->PostTask(
@@ skipping 265 matching lines @@
        ++iter2) {
     ServiceRecordState* service_state = new ServiceRecordState();
     service_state->gatt_uuid =
         BluetoothLowEnergyUuidToBluetoothUuid((*iter2)->uuid);
     service_record_states->push_back(service_state);
   }
   return true;
 }
 
 }  // namespace device