Run clang-modernize -use-nullptr over src/extensions/.

extensions/browser/api/bluetooth_low_energy/bluetooth_low_energy_event_router.cc

 // Copyright 2014 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 "extensions/browser/api/bluetooth_low_energy/bluetooth_low_energy_event_router.h"
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/values.h"
 #include "content/public/browser/browser_thread.h"
@@ skipping 139 matching lines @@
          "ApiResourceManager<BluetoothLowEnergyNotifySession>.";
   return manager;
 }
 
 }  // namespace
 
 namespace extensions {
 
 BluetoothLowEnergyEventRouter::BluetoothLowEnergyEventRouter(
     content::BrowserContext* context)
-    : adapter_(NULL), browser_context_(context), weak_ptr_factory_(this) {
+    : adapter_(nullptr), browser_context_(context), weak_ptr_factory_(this) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(browser_context_);
   VLOG(1) << "Initializing BluetoothLowEnergyEventRouter.";
 
   if (!IsBluetoothSupported()) {
     VLOG(1) << "Bluetooth not supported on the current platform.";
     return;
   }
 }
 
 BluetoothLowEnergyEventRouter::~BluetoothLowEnergyEventRouter() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   if (!adapter_.get())
     return;
 
   adapter_->RemoveObserver(this);
-  adapter_ = NULL;
+  adapter_ = nullptr;
 }
 
 bool BluetoothLowEnergyEventRouter::IsBluetoothSupported() const {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   return adapter_.get() ||
          BluetoothAdapterFactory::IsBluetoothAdapterAvailable();
 }
 
 bool BluetoothLowEnergyEventRouter::InitializeAdapterAndInvokeCallback(
     const base::Closure& callback) {
   if (!IsBluetoothSupported())
     return false;
 
   if (adapter_.get()) {
     callback.Run();
     return true;
   }
 
   BluetoothAdapterFactory::GetAdapter(
       base::Bind(&BluetoothLowEnergyEventRouter::OnGetAdapter,
                  weak_ptr_factory_.GetWeakPtr(),
                  callback));
   return true;
 }
 
 bool BluetoothLowEnergyEventRouter::HasAdapter() const {
-  return (adapter_.get() != NULL);
+  return (adapter_.get() != nullptr);
 }
 
 void BluetoothLowEnergyEventRouter::Connect(
     bool persistent,
     const Extension* extension,
     const std::string& device_address,
     const base::Closure& callback,
     const ErrorCallback& error_callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   if (!adapter_.get()) {
@@ skipping 921 matching lines @@
         extension_id, event.Pass());
   }
 }
 
 BluetoothGattService* BluetoothLowEnergyEventRouter::FindServiceById(
     const std::string& instance_id) const {
   InstanceIdMap::const_iterator iter =
       service_id_to_device_address_.find(instance_id);
   if (iter == service_id_to_device_address_.end()) {
     VLOG(1) << "GATT service identifier unknown: " << instance_id;
-    return NULL;
+    return nullptr;
   }
 
   const std::string& address = iter->second;
 
   BluetoothDevice* device = adapter_->GetDevice(address);
   if (!device) {
     VLOG(1) << "Bluetooth device not found: " << address;
-    return NULL;
+    return nullptr;
   }
 
   BluetoothGattService* service = device->GetGattService(instance_id);
   if (!service) {
     VLOG(1) << "GATT service with ID \"" << instance_id
             << "\" not found on device \"" << address << "\"";
-    return NULL;
+    return nullptr;
   }
 
   return service;
 }
 
 BluetoothGattCharacteristic*
 BluetoothLowEnergyEventRouter::FindCharacteristicById(
     const std::string& instance_id) const {
   InstanceIdMap::const_iterator iter = chrc_id_to_service_id_.find(instance_id);
   if (iter == chrc_id_to_service_id_.end()) {
     VLOG(1) << "GATT characteristic identifier unknown: " << instance_id;
-    return NULL;
+    return nullptr;
   }
 
   const std::string& service_id = iter->second;
 
   BluetoothGattService* service = FindServiceById(service_id);
   if (!service) {
     VLOG(1) << "Failed to obtain service for characteristic: " << instance_id;
-    return NULL;
+    return nullptr;
   }
 
   BluetoothGattCharacteristic* characteristic =
       service->GetCharacteristic(instance_id);
   if (!characteristic) {
     VLOG(1) << "GATT characteristic with ID \"" << instance_id
             << "\" not found on service \"" << service_id << "\"";
-    return NULL;
+    return nullptr;
   }
 
   return characteristic;
 }
 
 BluetoothGattDescriptor* BluetoothLowEnergyEventRouter::FindDescriptorById(
     const std::string& instance_id) const {
   InstanceIdMap::const_iterator iter = desc_id_to_chrc_id_.find(instance_id);
   if (iter == desc_id_to_chrc_id_.end()) {
     VLOG(1) << "GATT descriptor identifier unknown: " << instance_id;
-    return NULL;
+    return nullptr;
   }
 
   const std::string& chrc_id = iter->second;
   BluetoothGattCharacteristic* chrc = FindCharacteristicById(chrc_id);
   if (!chrc) {
     VLOG(1) << "Failed to obtain characteristic for descriptor: "
             << instance_id;
-    return NULL;
+    return nullptr;
   }
 
   BluetoothGattDescriptor* descriptor = chrc->GetDescriptor(instance_id);
   if (!descriptor) {
     VLOG(1) << "GATT descriptor with ID \"" << instance_id
             << "\" not found on characteristic \"" << chrc_id << "\"";
-    return NULL;
+    return nullptr;
   }
 
   return descriptor;
 }
 
 void BluetoothLowEnergyEventRouter::OnValueSuccess(
     const base::Closure& callback,
     const std::vector<uint8>& value) {
   VLOG(2) << "Remote characteristic/descriptor value read successful.";
   callback.Run();
@@ skipping 118 matching lines @@
 }
 
 BluetoothLowEnergyConnection* BluetoothLowEnergyEventRouter::FindConnection(
     const std::string& extension_id,
     const std::string& device_address) {
   ConnectionResourceManager* manager =
       GetConnectionResourceManager(browser_context_);
 
   base::hash_set<int>* connection_ids = manager->GetResourceIds(extension_id);
   if (!connection_ids)
-    return NULL;
+    return nullptr;
 
   for (base::hash_set<int>::const_iterator iter = connection_ids->begin();
        iter != connection_ids->end();
        ++iter) {
     extensions::BluetoothLowEnergyConnection* conn =
         manager->Get(extension_id, *iter);
     if (!conn)
       continue;
 
     if (conn->GetConnection()->GetDeviceAddress() == device_address)
       return conn;
   }
 
-  return NULL;
+  return nullptr;
 }
 
 bool BluetoothLowEnergyEventRouter::RemoveConnection(
     const std::string& extension_id,
     const std::string& device_address) {
   ConnectionResourceManager* manager =
       GetConnectionResourceManager(browser_context_);
 
   base::hash_set<int>* connection_ids = manager->GetResourceIds(extension_id);
   if (!connection_ids)
@@ skipping 16 matching lines @@
 
 BluetoothLowEnergyNotifySession*
 BluetoothLowEnergyEventRouter::FindNotifySession(
     const std::string& extension_id,
     const std::string& characteristic_id) {
   NotifySessionResourceManager* manager =
       GetNotifySessionResourceManager(browser_context_);
 
   base::hash_set<int>* ids = manager->GetResourceIds(extension_id);
   if (!ids)
-    return NULL;
+    return nullptr;
 
   for (base::hash_set<int>::const_iterator iter = ids->begin();
        iter != ids->end();
        ++iter) {
     BluetoothLowEnergyNotifySession* session =
         manager->Get(extension_id, *iter);
     if (!session)
       continue;
 
     if (session->GetSession()->GetCharacteristicIdentifier() ==
         characteristic_id)
       return session;
   }
 
-  return NULL;
+  return nullptr;
 }
 
 bool BluetoothLowEnergyEventRouter::RemoveNotifySession(
     const std::string& extension_id,
     const std::string& characteristic_id) {
   NotifySessionResourceManager* manager =
       GetNotifySessionResourceManager(browser_context_);
 
   base::hash_set<int>* ids = manager->GetResourceIds(extension_id);
   if (!ids)
@@ skipping 10 matching lines @@
       continue;
 
     manager->Remove(extension_id, *iter);
     return true;
   }
 
   return false;
 }
 
 }  // namespace extensions