Update chrome/ to use scoped_refptr<T>::get() rather than implicit "operator T*"

chrome/browser/extensions/api/bluetooth/bluetooth_event_router.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/extensions/api/bluetooth/bluetooth_event_router.h"
 
 #include <map>
 #include <string>
 
 #include "base/json/json_writer.h"
@@ skipping 19 matching lines @@
       responsible_for_discovery_(false),
       profile_(profile),
       adapter_(NULL),
       num_event_listeners_(0),
       next_socket_id_(1),
       weak_ptr_factory_(this) {
   DCHECK(profile_);
 }
 
 ExtensionBluetoothEventRouter::~ExtensionBluetoothEventRouter() {
-  if (adapter_) {
+  if (adapter_.get()) {
     adapter_->RemoveObserver(this);
     adapter_ = NULL;
   }
   DLOG_IF(WARNING, socket_map_.size() != 0)
       << "Bluetooth sockets are still open.";
   socket_map_.clear();
 
   for (BluetoothProfileMap::iterator iter = bluetooth_profile_map_.begin();
        iter != bluetooth_profile_map_.end();
        ++iter) {
     iter->second->Unregister();
   }
 }
 
 bool ExtensionBluetoothEventRouter::IsBluetoothSupported() const {
-  return adapter_ ||
+  return adapter_.get() ||
          device::BluetoothAdapterFactory::IsBluetoothAdapterAvailable();
 }
 
 void ExtensionBluetoothEventRouter::GetAdapter(
     const device::BluetoothAdapterFactory::AdapterCallback& callback) {
-  if (adapter_) {
+  if (adapter_.get()) {
     callback.Run(scoped_refptr<device::BluetoothAdapter>(adapter_));
     return;
   }
 
   device::BluetoothAdapterFactory::GetAdapter(callback);
 }
 
 void ExtensionBluetoothEventRouter::OnListenerAdded() {
   num_event_listeners_++;
   InitializeAdapterIfNeeded();
@@ skipping 111 matching lines @@
   scoped_ptr<ListValue> args(new ListValue());
   args->Append(result_socket.ToValue().release());
   scoped_ptr<Event> event(new Event(
       extensions::event_names::kBluetoothOnConnection, args.Pass()));
   ExtensionSystem::Get(profile_)->event_router()->DispatchEventToExtension(
       extension_id, event.Pass());
 }
 
 void ExtensionBluetoothEventRouter::AdapterPresentChanged(
     device::BluetoothAdapter* adapter, bool present) {
-  if (adapter != adapter_) {
+  if (adapter != adapter_.get()) {
     DVLOG(1) << "Ignoring event for adapter " << adapter->GetAddress();
     return;
   }
   DispatchAdapterStateEvent();
 }
 
 void ExtensionBluetoothEventRouter::AdapterPoweredChanged(
     device::BluetoothAdapter* adapter, bool has_power) {
-  if (adapter != adapter_) {
+  if (adapter != adapter_.get()) {
     DVLOG(1) << "Ignoring event for adapter " << adapter->GetAddress();
     return;
   }
   DispatchAdapterStateEvent();
 }
 
 void ExtensionBluetoothEventRouter::AdapterDiscoveringChanged(
     device::BluetoothAdapter* adapter, bool discovering) {
-  if (adapter != adapter_) {
+  if (adapter != adapter_.get()) {
     DVLOG(1) << "Ignoring event for adapter " << adapter->GetAddress();
     return;
   }
 
   if (!discovering) {
     send_discovery_events_ = false;
     responsible_for_discovery_ = false;
     discovered_devices_.clear();
   }
 
   DispatchAdapterStateEvent();
 }
 
 void ExtensionBluetoothEventRouter::DeviceAdded(
     device::BluetoothAdapter* adapter,
     device::BluetoothDevice* device) {
-  if (adapter != adapter_) {
+  if (adapter != adapter_.get()) {
     DVLOG(1) << "Ignoring event for adapter " << adapter->GetAddress();
     return;
   }
 
   extensions::api::bluetooth::Device* extension_device =
       new extensions::api::bluetooth::Device();
   extensions::api::bluetooth::BluetoothDeviceToApiDevice(
       *device, extension_device);
   discovered_devices_.push_back(extension_device);
 
   if (!send_discovery_events_)
     return;
 
   DispatchDeviceEvent(extensions::event_names::kBluetoothOnDeviceDiscovered,
                       *extension_device);
 }
 
 void ExtensionBluetoothEventRouter::InitializeAdapterIfNeeded() {
-  if (!adapter_) {
+  if (!adapter_.get()) {
     GetAdapter(base::Bind(&ExtensionBluetoothEventRouter::InitializeAdapter,
                           weak_ptr_factory_.GetWeakPtr()));
   }
 }
 
 void ExtensionBluetoothEventRouter::InitializeAdapter(
     scoped_refptr<device::BluetoothAdapter> adapter) {
-  if (!adapter_) {
+  if (!adapter_.get()) {
     adapter_ = adapter;
     adapter_->AddObserver(this);
   }
 }
 
 void ExtensionBluetoothEventRouter::MaybeReleaseAdapter() {
-  if (adapter_ && num_event_listeners_ == 0) {
+  if (adapter_.get() && num_event_listeners_ == 0) {
     adapter_->RemoveObserver(this);
     adapter_ = NULL;
   }
 }
 
 void ExtensionBluetoothEventRouter::DispatchAdapterStateEvent() {
   api::bluetooth::AdapterState state;
-  PopulateAdapterState(*adapter_, &state);
+  PopulateAdapterState(*adapter_.get(), &state);
 
   scoped_ptr<ListValue> args(new ListValue());
   args->Append(state.ToValue().release());
   scoped_ptr<Event> event(new Event(
       extensions::event_names::kBluetoothOnAdapterStateChanged,
       args.Pass()));
   ExtensionSystem::Get(profile_)->event_router()->BroadcastEvent(event.Pass());
 }
 
 }  // namespace extensions