Submission for C++ Readability

device/bluetooth/bluetooth_chromeos_unittest.cc

 // Copyright 2013 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 "base/memory/scoped_vector.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "base/strings/utf_string_conversions.h"
 #include "chromeos/dbus/dbus_thread_manager.h"
 #include "chromeos/dbus/fake_bluetooth_adapter_client.h"
@@ skipping 121 matching lines @@
   int request_passkey_count_;
   int display_pincode_count_;
   int display_passkey_count_;
   int keys_entered_count_;
   int confirm_passkey_count_;
   int authorize_pairing_count_;
   uint32 last_passkey_;
   uint32 last_entered_;
   std::string last_pincode_;
 
-  private:
-   // Some tests use a message loop since background processing is simulated;
-   // break out of those loops.
-   void QuitMessageLoop() {
-     if (base::MessageLoop::current() &&
-         base::MessageLoop::current()->is_running())
-       base::MessageLoop::current()->Quit();
-   }
+ private:
+  // Some tests use a message loop since background processing is simulated;
+  // break out of those loops.
+  void QuitMessageLoop() {
+    if (base::MessageLoop::current() &&
+        base::MessageLoop::current()->is_running()) {
+      base::MessageLoop::current()->Quit();
+    }
+  }
 };
 
 class BluetoothChromeOSTest : public testing::Test {
  public:
   void SetUp() override {
     scoped_ptr<DBusThreadManagerSetter> dbus_setter =
         chromeos::DBusThreadManager::GetSetterForTesting();
     // We need to initialize DBusThreadManager early to prevent
     // Bluetooth*::Create() methods from picking the real instead of fake
     // implementations.
@@ skipping 27 matching lines @@
          ++iter) {
       BluetoothDiscoverySession* session = *iter;
       if (!session->IsActive())
         continue;
       callback_count_ = 0;
       session->Stop(GetCallback(), GetErrorCallback());
       message_loop_.Run();
       ASSERT_EQ(1, callback_count_);
     }
     discovery_sessions_.clear();
-    adapter_ = NULL;
+    adapter_ = nullptr;
     DBusThreadManager::Shutdown();
   }
 
   // Generic callbacks
   void Callback() {
     ++callback_count_;
     QuitMessageLoop();
   }
 
   base::Closure GetCallback() {
@@ skipping 46 matching lines @@
   }
 
   void ErrorCompletionCallback(const std::string& error_message) {
     ++error_callback_count_;
     QuitMessageLoop();
   }
 
   // Call to fill the adapter_ member with a BluetoothAdapter instance.
   void GetAdapter() {
     adapter_ = new BluetoothAdapterChromeOS();
-    ASSERT_TRUE(adapter_.get() != NULL);
+    ASSERT_TRUE(adapter_.get() != nullptr);
     ASSERT_TRUE(adapter_->IsInitialized());
   }
 
   // Run a discovery phase until the named device is detected, or if the named
   // device is not created, the discovery process ends without finding it.
   //
   // The correct behavior of discovery is tested by the "Discovery" test case
   // without using this function.
   void DiscoverDevice(const std::string& address) {
-    ASSERT_TRUE(adapter_.get() != NULL);
-    ASSERT_TRUE(base::MessageLoop::current() != NULL);
+    ASSERT_TRUE(adapter_.get() != nullptr);
+    ASSERT_TRUE(base::MessageLoop::current() != nullptr);
     fake_bluetooth_device_client_->SetSimulationIntervalMs(10);
 
     TestBluetoothAdapterObserver observer(adapter_);
 
     adapter_->SetPowered(true, GetCallback(), GetErrorCallback());
     adapter_->StartDiscoverySession(
         base::Bind(&BluetoothChromeOSTest::DiscoverySessionCallback,
                    base::Unretained(this)),
         GetErrorCallback());
     base::MessageLoop::current()->Run();
@@ skipping 37 matching lines @@
   enum BluetoothDevice::ConnectErrorCode last_connect_error_;
   std::string last_client_error_;
   ScopedVector<BluetoothDiscoverySession> discovery_sessions_;
   BluetoothAdapterProfileChromeOS* adapter_profile_;
 
  private:
   // Some tests use a message loop since background processing is simulated;
   // break out of those loops.
   void QuitMessageLoop() {
     if (base::MessageLoop::current() &&
-        base::MessageLoop::current()->is_running())
+        base::MessageLoop::current()->is_running()) {
       base::MessageLoop::current()->Quit();
+    }
   }
 };
 
 TEST_F(BluetoothChromeOSTest, AlreadyPresent) {
   GetAdapter();
 
   // This verifies that the class gets the list of adapters when created;
   // and initializes with an existing adapter if there is one.
   EXPECT_TRUE(adapter_->IsPresent());
   EXPECT_FALSE(adapter_->IsPowered());
@@ skipping 1046 matching lines @@
   message_loop_.Run();
 
   EXPECT_EQ(1, callback_count_);
   EXPECT_EQ(0, error_callback_count_);
 
   ASSERT_TRUE(adapter_->IsPowered());
   ASSERT_FALSE(adapter_->IsDiscovering());
   ASSERT_EQ((size_t)1, discovery_sessions_.size());
   ASSERT_FALSE(discovery_sessions_[0]->IsActive());
   ASSERT_EQ(discovery_sessions_[0]->GetDiscoveryFilter(),
-            (BluetoothDiscoveryFilter*)NULL);
+            (BluetoothDiscoveryFilter*)nullptr);
 
   filter = fake_bluetooth_adapter_client_->GetDiscoveryFilter();
   EXPECT_EQ(nullptr, filter);
 }
 
 TEST_F(BluetoothChromeOSTest, SetDiscoveryFilterBeforeStartDiscoveryFail) {
   // Test a simulated discovery session.
   fake_bluetooth_device_client_->SetSimulationIntervalMs(10);
   GetAdapter();
 
@@ skipping 118 matching lines @@
 
   message_loop_.Run();
 
   EXPECT_EQ(2, callback_count_);
   EXPECT_EQ(0, error_callback_count_);
 
   ASSERT_TRUE(adapter_->IsPowered());
   ASSERT_FALSE(adapter_->IsDiscovering());
   ASSERT_FALSE(discovery_sessions_[0]->IsActive());
   ASSERT_EQ(discovery_sessions_[0]->GetDiscoveryFilter(),
-            (BluetoothDiscoveryFilter*)NULL);
+            (BluetoothDiscoveryFilter*)nullptr);
   ASSERT_FALSE(discovery_sessions_[1]->IsActive());
   ASSERT_EQ(discovery_sessions_[1]->GetDiscoveryFilter(),
-            (BluetoothDiscoveryFilter*)NULL);
+            (BluetoothDiscoveryFilter*)nullptr);
 
   filter = fake_bluetooth_adapter_client_->GetDiscoveryFilter();
   EXPECT_EQ(nullptr, filter);
 }
 
 // Call StartFilteredDiscovery twice (2nd time while 1st call is still pending).
 // Make the first SetDiscoveryFilter fail and the second one succeed. It should
 // end up with one active discovery session.
 TEST_F(BluetoothChromeOSTest,
        QueuedSetDiscoveryFilterBeforeStartDiscoveryFail) {
@@ skipping 80 matching lines @@
 
   message_loop_.Run();
 
   EXPECT_EQ(1, callback_count_);
   EXPECT_EQ(0, error_callback_count_);
 
   ASSERT_TRUE(adapter_->IsPowered());
   ASSERT_FALSE(adapter_->IsDiscovering());
   ASSERT_FALSE(discovery_sessions_[0]->IsActive());
   ASSERT_EQ(discovery_sessions_[0]->GetDiscoveryFilter(),
-            (BluetoothDiscoveryFilter*)NULL);
+            (BluetoothDiscoveryFilter*)nullptr);
 
   filter = fake_bluetooth_adapter_client_->GetDiscoveryFilter();
   EXPECT_EQ(nullptr, filter);
 }
 
 TEST_F(BluetoothChromeOSTest, SetDiscoveryFilterAfterStartDiscovery) {
   // Test a simulated discovery session.
   fake_bluetooth_device_client_->SetSimulationIntervalMs(10);
   GetAdapter();
 
@@ skipping 13 matching lines @@
   EXPECT_EQ(0, error_callback_count_);
   callback_count_ = 0;
 
   ASSERT_TRUE(adapter_->IsPowered());
   ASSERT_TRUE(adapter_->IsDiscovering());
   ASSERT_EQ((size_t)1, discovery_sessions_.size());
   ASSERT_TRUE(discovery_sessions_[0]->IsActive());
   EXPECT_EQ(1, observer.discovering_changed_count());
   observer.Reset();
 
-  auto nullInstance = scoped_ptr<BluetoothDiscoveryFilter>();
-  nullInstance.reset();
-  ASSERT_EQ(discovery_sessions_[0]->GetDiscoveryFilter(), nullInstance.get());
+  auto null_instance = scoped_ptr<BluetoothDiscoveryFilter>();
+  null_instance.reset();
+  ASSERT_EQ(discovery_sessions_[0]->GetDiscoveryFilter(), null_instance.get());
 
   auto filter = fake_bluetooth_adapter_client_->GetDiscoveryFilter();
   EXPECT_EQ(nullptr, filter);
 
   BluetoothDiscoveryFilter* df = new BluetoothDiscoveryFilter(
       BluetoothDiscoveryFilter::Transport::TRANSPORT_LE);
   df->SetRSSI(-60);
   df->AddUUID(BluetoothUUID("1000"));
   scoped_ptr<BluetoothDiscoveryFilter> discovery_filter(df);
 
@@ skipping 26 matching lines @@
   message_loop_.Run();
 
   EXPECT_EQ(1, callback_count_);
   EXPECT_EQ(0, error_callback_count_);
 
   ASSERT_TRUE(adapter_->IsPowered());
   ASSERT_FALSE(adapter_->IsDiscovering());
   ASSERT_EQ((size_t)1, discovery_sessions_.size());
   ASSERT_FALSE(discovery_sessions_[0]->IsActive());
   ASSERT_EQ(discovery_sessions_[0]->GetDiscoveryFilter(),
-            (BluetoothDiscoveryFilter*)NULL);
+            (BluetoothDiscoveryFilter*)nullptr);
 
   filter = fake_bluetooth_adapter_client_->GetDiscoveryFilter();
   EXPECT_EQ(nullptr, filter);
 }
 
 // This unit test asserts that the basic reference counting, and filter merging
 // works correctly for discovery requests done via the BluetoothAdapter.
 TEST_F(BluetoothChromeOSTest, SetDiscoveryFilterBeforeStartDiscoveryMultiple) {
   GetAdapter();
   adapter_->SetPowered(true, base::Bind(&BluetoothChromeOSTest::Callback,
@@ skipping 560 matching lines @@
   devices = adapter_->GetDevices();
   ASSERT_EQ(1U, devices.size());
 }
 
 TEST_F(BluetoothChromeOSTest, ForgetUnpairedDevice) {
   GetAdapter();
   DiscoverDevices();
 
   BluetoothDevice* device = adapter_->GetDevice(
       FakeBluetoothDeviceClient::kConnectUnpairableAddress);
-  ASSERT_TRUE(device != NULL);
+  ASSERT_TRUE(device != nullptr);
   ASSERT_FALSE(device->IsPaired());
 
   // Connect the device so it becomes trusted and remembered.
-  device->Connect(NULL, GetCallback(),
+  device->Connect(nullptr, GetCallback(),
                   base::Bind(&BluetoothChromeOSTest::ConnectErrorCallback,
                              base::Unretained(this)));
 
   ASSERT_EQ(1, callback_count_);
   ASSERT_EQ(0, error_callback_count_);
   callback_count_ = 0;
 
   ASSERT_TRUE(device->IsConnected());
   ASSERT_FALSE(device->IsConnecting());
 
@@ skipping 10 matching lines @@
   device->Forget(GetErrorCallback());
   EXPECT_EQ(0, error_callback_count_);
 
   EXPECT_EQ(1, observer.device_removed_count());
   EXPECT_EQ(FakeBluetoothDeviceClient::kConnectUnpairableAddress,
             observer.last_device_address());
 
   // GetDevices shouldn't return the device either.
   device = adapter_->GetDevice(
       FakeBluetoothDeviceClient::kConnectUnpairableAddress);
-  EXPECT_FALSE(device != NULL);
+  EXPECT_FALSE(device != nullptr);
 }
 
 TEST_F(BluetoothChromeOSTest, ConnectPairedDevice) {
   GetAdapter();
 
   BluetoothDevice* device = adapter_->GetDevice(
       FakeBluetoothDeviceClient::kPairedDeviceAddress);
-  ASSERT_TRUE(device != NULL);
+  ASSERT_TRUE(device != nullptr);
   ASSERT_TRUE(device->IsPaired());
 
   TestBluetoothAdapterObserver observer(adapter_);
 
   // Connect without a pairing delegate; since the device is already Paired
   // this should succeed and the device should become connected.
-  device->Connect(NULL, GetCallback(),
+  device->Connect(nullptr, GetCallback(),
                   base::Bind(&BluetoothChromeOSTest::ConnectErrorCallback,
                              base::Unretained(this)));
 
   EXPECT_EQ(1, callback_count_);
   EXPECT_EQ(0, error_callback_count_);
 
   // Two changes for connecting, one for connected and one for for trusted
   // after connecting.
   EXPECT_EQ(4, observer.device_changed_count());
   EXPECT_EQ(device, observer.last_device());
 
   EXPECT_TRUE(device->IsConnected());
   EXPECT_FALSE(device->IsConnecting());
 }
 
 TEST_F(BluetoothChromeOSTest, ConnectUnpairableDevice) {
   GetAdapter();
   DiscoverDevices();
 
   BluetoothDevice* device = adapter_->GetDevice(
       FakeBluetoothDeviceClient::kConnectUnpairableAddress);
-  ASSERT_TRUE(device != NULL);
+  ASSERT_TRUE(device != nullptr);
   ASSERT_FALSE(device->IsPaired());
 
   TestBluetoothAdapterObserver observer(adapter_);
 
   // Connect without a pairing delegate; since the device does not require
   // pairing, this should succeed and the device should become connected.
-  device->Connect(NULL, GetCallback(),
+  device->Connect(nullptr, GetCallback(),
                   base::Bind(&BluetoothChromeOSTest::ConnectErrorCallback,
                              base::Unretained(this)));
 
   EXPECT_EQ(1, callback_count_);
   EXPECT_EQ(0, error_callback_count_);
 
   // Two changes for connecting, one for connected, one for for trusted after
   // connection, and one for the reconnect mode (IsConnectable).
   EXPECT_EQ(5, observer.device_changed_count());
   EXPECT_EQ(device, observer.last_device());
@@ skipping 12 matching lines @@
   ASSERT_EQ(1U, uuids.size());
   EXPECT_EQ(uuids[0], BluetoothUUID("1124"));
   EXPECT_FALSE(device->IsConnectable());
 }
 
 TEST_F(BluetoothChromeOSTest, ConnectConnectedDevice) {
   GetAdapter();
 
   BluetoothDevice* device = adapter_->GetDevice(
       FakeBluetoothDeviceClient::kPairedDeviceAddress);
-  ASSERT_TRUE(device != NULL);
+  ASSERT_TRUE(device != nullptr);
   ASSERT_TRUE(device->IsPaired());
 
-  device->Connect(NULL, GetCallback(),
+  device->Connect(nullptr, GetCallback(),
                   base::Bind(&BluetoothChromeOSTest::ConnectErrorCallback,
                              base::Unretained(this)));
 
   ASSERT_EQ(1, callback_count_);
   ASSERT_EQ(0, error_callback_count_);
   callback_count_ = 0;
 
   ASSERT_TRUE(device->IsConnected());
 
   // Connect again; since the device is already Connected, this shouldn't do
   // anything to initiate the connection.
   TestBluetoothAdapterObserver observer(adapter_);
 
-  device->Connect(NULL, GetCallback(),
+  device->Connect(nullptr, GetCallback(),
                   base::Bind(&BluetoothChromeOSTest::ConnectErrorCallback,
                              base::Unretained(this)));
 
   EXPECT_EQ(1, callback_count_);
   EXPECT_EQ(0, error_callback_count_);
 
   // The observer will be called because Connecting will toggle true and false,
   // and the trusted property will be updated to true.
   EXPECT_EQ(3, observer.device_changed_count());
 
   EXPECT_TRUE(device->IsConnected());
   EXPECT_FALSE(device->IsConnecting());
 }
 
 TEST_F(BluetoothChromeOSTest, ConnectDeviceFails) {
   GetAdapter();
   DiscoverDevices();
 
   BluetoothDevice* device = adapter_->GetDevice(
       FakeBluetoothDeviceClient::kLegacyAutopairAddress);
-  ASSERT_TRUE(device != NULL);
+  ASSERT_TRUE(device != nullptr);
   ASSERT_FALSE(device->IsPaired());
 
   TestBluetoothAdapterObserver observer(adapter_);
 
   // Connect without a pairing delegate; since the device requires pairing,
   // this should fail with an error.
-  device->Connect(NULL, GetCallback(),
+  device->Connect(nullptr, GetCallback(),
                   base::Bind(&BluetoothChromeOSTest::ConnectErrorCallback,
                              base::Unretained(this)));
 
   EXPECT_EQ(0, callback_count_);
   EXPECT_EQ(1, error_callback_count_);
   EXPECT_EQ(BluetoothDevice::ERROR_FAILED, last_connect_error_);
 
   EXPECT_EQ(2, observer.device_changed_count());
 
   EXPECT_FALSE(device->IsConnected());
   EXPECT_FALSE(device->IsConnecting());
 }
 
 TEST_F(BluetoothChromeOSTest, DisconnectDevice) {
   GetAdapter();
 
   BluetoothDevice* device = adapter_->GetDevice(
       FakeBluetoothDeviceClient::kPairedDeviceAddress);
-  ASSERT_TRUE(device != NULL);
+  ASSERT_TRUE(device != nullptr);
   ASSERT_TRUE(device->IsPaired());
 
-  device->Connect(NULL, GetCallback(),
+  device->Connect(nullptr, GetCallback(),
                   base::Bind(&BluetoothChromeOSTest::ConnectErrorCallback,
                              base::Unretained(this)));
 
   ASSERT_EQ(1, callback_count_);
   ASSERT_EQ(0, error_callback_count_);
   callback_count_ = 0;
 
   ASSERT_TRUE(device->IsConnected());
   ASSERT_FALSE(device->IsConnecting());
 
@@ skipping 10 matching lines @@
   EXPECT_EQ(device, observer.last_device());
 
   EXPECT_FALSE(device->IsConnected());
 }
 
 TEST_F(BluetoothChromeOSTest, DisconnectUnconnectedDevice) {
   GetAdapter();
 
   BluetoothDevice* device = adapter_->GetDevice(
       FakeBluetoothDeviceClient::kPairedDeviceAddress);
-  ASSERT_TRUE(device != NULL);
+  ASSERT_TRUE(device != nullptr);
   ASSERT_TRUE(device->IsPaired());
   ASSERT_FALSE(device->IsConnected());
 
   // Disconnect the device, we should see the observer method fire and the
   // device get dropped.
   TestBluetoothAdapterObserver observer(adapter_);
 
   device->Disconnect(GetCallback(), GetErrorCallback());
 
   EXPECT_EQ(0, callback_count_);
   EXPECT_EQ(1, error_callback_count_);
 
   EXPECT_EQ(0, observer.device_changed_count());
 
   EXPECT_FALSE(device->IsConnected());
 }
 
 TEST_F(BluetoothChromeOSTest, PairLegacyAutopair) {
   fake_bluetooth_device_client_->SetSimulationIntervalMs(10);
 
   GetAdapter();
   DiscoverDevices();
 
   // The Legacy Autopair device requires no PIN or Passkey to pair because
   // the daemon provides 0000 to the device for us.
   BluetoothDevice* device = adapter_->GetDevice(
       FakeBluetoothDeviceClient::kLegacyAutopairAddress);
-  ASSERT_TRUE(device != NULL);
+  ASSERT_TRUE(device != nullptr);
   ASSERT_FALSE(device->IsPaired());
 
   TestBluetoothAdapterObserver observer(adapter_);
 
   TestPairingDelegate pairing_delegate;
   device->Connect(&pairing_delegate, GetCallback(),
                   base::Bind(&BluetoothChromeOSTest::ConnectErrorCallback,
                              base::Unretained(this)));
 
   EXPECT_EQ(0, pairing_delegate.call_count_);
@@ skipping 30 matching lines @@
 
 TEST_F(BluetoothChromeOSTest, PairDisplayPinCode) {
   fake_bluetooth_device_client_->SetSimulationIntervalMs(10);
 
   GetAdapter();
   DiscoverDevices();
 
   // Requires that we display a randomly generated PIN on the screen.
   BluetoothDevice* device = adapter_->GetDevice(
       FakeBluetoothDeviceClient::kDisplayPinCodeAddress);
-  ASSERT_TRUE(device != NULL);
+  ASSERT_TRUE(device != nullptr);
   ASSERT_FALSE(device->IsPaired());
 
   TestBluetoothAdapterObserver observer(adapter_);
 
   TestPairingDelegate pairing_delegate;
   device->Connect(&pairing_delegate, GetCallback(),
                   base::Bind(&BluetoothChromeOSTest::ConnectErrorCallback,
                              base::Unretained(this)));
 
   EXPECT_EQ(1, pairing_delegate.call_count_);
@@ skipping 33 matching lines @@
 TEST_F(BluetoothChromeOSTest, PairDisplayPasskey) {
   fake_bluetooth_device_client_->SetSimulationIntervalMs(10);
 
   GetAdapter();
   DiscoverDevices();
 
   // Requires that we display a randomly generated Passkey on the screen,
   // and notifies us as it's typed in.
   BluetoothDevice* device = adapter_->GetDevice(
       FakeBluetoothDeviceClient::kDisplayPasskeyAddress);
-  ASSERT_TRUE(device != NULL);
+  ASSERT_TRUE(device != nullptr);
   ASSERT_FALSE(device->IsPaired());
 
   TestBluetoothAdapterObserver observer(adapter_);
 
   TestPairingDelegate pairing_delegate;
   device->Connect(&pairing_delegate, GetCallback(),
                   base::Bind(&BluetoothChromeOSTest::ConnectErrorCallback,
                              base::Unretained(this)));
 
   // One call for DisplayPasskey() and one for KeysEntered().
   EXPECT_EQ(2, pairing_delegate.call_count_);
   EXPECT_EQ(1, pairing_delegate.display_passkey_count_);
   EXPECT_EQ(123456U, pairing_delegate.last_passkey_);
   EXPECT_EQ(1, pairing_delegate.keys_entered_count_);
   EXPECT_EQ(0U, pairing_delegate.last_entered_);
 
   EXPECT_TRUE(device->IsConnecting());
 
   // One call to KeysEntered() for each key, including [enter].
-  for(int i = 1; i <= 7; ++i) {
+  for (int i = 1; i <= 7; ++i) {
     message_loop_.Run();
 
     EXPECT_EQ(2 + i, pairing_delegate.call_count_);
     EXPECT_EQ(1 + i, pairing_delegate.keys_entered_count_);
     EXPECT_EQ(static_cast<uint32_t>(i), pairing_delegate.last_entered_);
   }
 
   message_loop_.Run();
 
   // 8 KeysEntered notifications (0 to 7, inclusive) and one aditional call for
@@ skipping 33 matching lines @@
 
 TEST_F(BluetoothChromeOSTest, PairRequestPinCode) {
   fake_bluetooth_device_client_->SetSimulationIntervalMs(10);
 
   GetAdapter();
   DiscoverDevices();
 
   // Requires that the user enters a PIN for them.
   BluetoothDevice* device = adapter_->GetDevice(
       FakeBluetoothDeviceClient::kRequestPinCodeAddress);
-  ASSERT_TRUE(device != NULL);
+  ASSERT_TRUE(device != nullptr);
   ASSERT_FALSE(device->IsPaired());
 
   TestBluetoothAdapterObserver observer(adapter_);
 
   TestPairingDelegate pairing_delegate;
   device->Connect(&pairing_delegate, GetCallback(),
                   base::Bind(&BluetoothChromeOSTest::ConnectErrorCallback,
                              base::Unretained(this)));
 
   EXPECT_EQ(1, pairing_delegate.call_count_);
@@ skipping 33 matching lines @@
 
 TEST_F(BluetoothChromeOSTest, PairConfirmPasskey) {
   fake_bluetooth_device_client_->SetSimulationIntervalMs(10);
 
   GetAdapter();
   DiscoverDevices();
 
   // Requests that we confirm a displayed passkey.
   BluetoothDevice* device = adapter_->GetDevice(
       FakeBluetoothDeviceClient::kConfirmPasskeyAddress);
-  ASSERT_TRUE(device != NULL);
+  ASSERT_TRUE(device != nullptr);
   ASSERT_FALSE(device->IsPaired());
 
   TestBluetoothAdapterObserver observer(adapter_);
 
   TestPairingDelegate pairing_delegate;
   device->Connect(&pairing_delegate, GetCallback(),
                   base::Bind(&BluetoothChromeOSTest::ConnectErrorCallback,
                              base::Unretained(this)));
 
   EXPECT_EQ(1, pairing_delegate.call_count_);
@@ skipping 31 matching lines @@
 TEST_F(BluetoothChromeOSTest, PairRequestPasskey) {
   fake_bluetooth_device_client_->SetSimulationIntervalMs(10);
 
   GetAdapter();
   DiscoverDevices();
 
   // Requires that the user enters a Passkey, this would be some kind of
   // device that has a display, but doesn't use "just works" - maybe a car?
   BluetoothDevice* device = adapter_->GetDevice(
       FakeBluetoothDeviceClient::kRequestPasskeyAddress);
-  ASSERT_TRUE(device != NULL);
+  ASSERT_TRUE(device != nullptr);
   ASSERT_FALSE(device->IsPaired());
 
   TestBluetoothAdapterObserver observer(adapter_);
 
   TestPairingDelegate pairing_delegate;
   device->Connect(&pairing_delegate, GetCallback(),
                   base::Bind(&BluetoothChromeOSTest::ConnectErrorCallback,
                              base::Unretained(this)));
 
   EXPECT_EQ(1, pairing_delegate.call_count_);
@@ skipping 30 matching lines @@
 TEST_F(BluetoothChromeOSTest, PairJustWorks) {
   fake_bluetooth_device_client_->SetSimulationIntervalMs(10);
 
   GetAdapter();
   DiscoverDevices();
 
   // Uses just-works pairing, since this is an outgoing pairing, no delegate
   // interaction is required.
   BluetoothDevice* device = adapter_->GetDevice(
       FakeBluetoothDeviceClient::kJustWorksAddress);
-  ASSERT_TRUE(device != NULL);
+  ASSERT_TRUE(device != nullptr);
   ASSERT_FALSE(device->IsPaired());
 
   TestBluetoothAdapterObserver observer(adapter_);
 
   TestPairingDelegate pairing_delegate;
   device->Connect(&pairing_delegate, GetCallback(),
                   base::Bind(&BluetoothChromeOSTest::ConnectErrorCallback,
                              base::Unretained(this)));
 
   EXPECT_EQ(0, pairing_delegate.call_count_);
@@ skipping 24 matching lines @@
 }
 
 TEST_F(BluetoothChromeOSTest, PairUnpairableDeviceFails) {
   fake_bluetooth_device_client_->SetSimulationIntervalMs(10);
 
   GetAdapter();
   DiscoverDevice(FakeBluetoothDeviceClient::kUnconnectableDeviceAddress);
 
   BluetoothDevice* device = adapter_->GetDevice(
       FakeBluetoothDeviceClient::kUnpairableDeviceAddress);
-  ASSERT_TRUE(device != NULL);
+  ASSERT_TRUE(device != nullptr);
   ASSERT_FALSE(device->IsPaired());
 
   TestBluetoothAdapterObserver observer(adapter_);
 
   TestPairingDelegate pairing_delegate;
   device->Connect(&pairing_delegate, GetCallback(),
                   base::Bind(&BluetoothChromeOSTest::ConnectErrorCallback,
                              base::Unretained(this)));
 
   EXPECT_EQ(0, pairing_delegate.call_count_);
@@ skipping 14 matching lines @@
 
 TEST_F(BluetoothChromeOSTest, PairingFails) {
   fake_bluetooth_device_client_->SetSimulationIntervalMs(10);
 
   GetAdapter();
   DiscoverDevice(FakeBluetoothDeviceClient::kVanishingDeviceAddress);
 
   // The vanishing device times out during pairing
   BluetoothDevice* device = adapter_->GetDevice(
       FakeBluetoothDeviceClient::kVanishingDeviceAddress);
-  ASSERT_TRUE(device != NULL);
+  ASSERT_TRUE(device != nullptr);
   ASSERT_FALSE(device->IsPaired());
 
   TestBluetoothAdapterObserver observer(adapter_);
 
   TestPairingDelegate pairing_delegate;
   device->Connect(&pairing_delegate, GetCallback(),
                   base::Bind(&BluetoothChromeOSTest::ConnectErrorCallback,
                              base::Unretained(this)));
 
   EXPECT_EQ(0, pairing_delegate.call_count_);
@@ skipping 15 matching lines @@
 TEST_F(BluetoothChromeOSTest, PairingFailsAtConnection) {
   fake_bluetooth_device_client_->SetSimulationIntervalMs(10);
 
   GetAdapter();
   DiscoverDevices();
 
   // Everything seems to go according to plan with the unconnectable device;
   // it pairs, but then you can't make connections to it after.
   BluetoothDevice* device = adapter_->GetDevice(
       FakeBluetoothDeviceClient::kUnconnectableDeviceAddress);
-  ASSERT_TRUE(device != NULL);
+  ASSERT_TRUE(device != nullptr);
   ASSERT_FALSE(device->IsPaired());
 
   TestBluetoothAdapterObserver observer(adapter_);
 
   TestPairingDelegate pairing_delegate;
   device->Connect(&pairing_delegate, GetCallback(),
                   base::Bind(&BluetoothChromeOSTest::ConnectErrorCallback,
                              base::Unretained(this)));
 
   EXPECT_EQ(0, pairing_delegate.call_count_);
@@ skipping 26 matching lines @@
 
 TEST_F(BluetoothChromeOSTest, PairingRejectedAtPinCode) {
   fake_bluetooth_device_client_->SetSimulationIntervalMs(10);
 
   GetAdapter();
   DiscoverDevices();
 
   // Reject the pairing after we receive a request for the PIN code.
   BluetoothDevice* device = adapter_->GetDevice(
       FakeBluetoothDeviceClient::kRequestPinCodeAddress);
-  ASSERT_TRUE(device != NULL);
+  ASSERT_TRUE(device != nullptr);
   ASSERT_FALSE(device->IsPaired());
 
   TestBluetoothAdapterObserver observer(adapter_);
 
   TestPairingDelegate pairing_delegate;
   device->Connect(&pairing_delegate, GetCallback(),
                   base::Bind(&BluetoothChromeOSTest::ConnectErrorCallback,
                              base::Unretained(this)));
 
   EXPECT_EQ(1, pairing_delegate.call_count_);
@@ skipping 17 matching lines @@
 
 TEST_F(BluetoothChromeOSTest, PairingCancelledAtPinCode) {
   fake_bluetooth_device_client_->SetSimulationIntervalMs(10);
 
   GetAdapter();
   DiscoverDevices();
 
   // Cancel the pairing after we receive a request for the PIN code.
   BluetoothDevice* device = adapter_->GetDevice(
       FakeBluetoothDeviceClient::kRequestPinCodeAddress);
-  ASSERT_TRUE(device != NULL);
+  ASSERT_TRUE(device != nullptr);
   ASSERT_FALSE(device->IsPaired());
 
   TestBluetoothAdapterObserver observer(adapter_);
 
   TestPairingDelegate pairing_delegate;
   device->Connect(&pairing_delegate, GetCallback(),
                   base::Bind(&BluetoothChromeOSTest::ConnectErrorCallback,
                              base::Unretained(this)));
 
   EXPECT_EQ(1, pairing_delegate.call_count_);
@@ skipping 17 matching lines @@
 
 TEST_F(BluetoothChromeOSTest, PairingRejectedAtPasskey) {
   fake_bluetooth_device_client_->SetSimulationIntervalMs(10);
 
   GetAdapter();
   DiscoverDevices();
 
   // Reject the pairing after we receive a request for the passkey.
   BluetoothDevice* device = adapter_->GetDevice(
       FakeBluetoothDeviceClient::kRequestPasskeyAddress);
-  ASSERT_TRUE(device != NULL);
+  ASSERT_TRUE(device != nullptr);
   ASSERT_FALSE(device->IsPaired());
 
   TestBluetoothAdapterObserver observer(adapter_);
 
   TestPairingDelegate pairing_delegate;
   device->Connect(&pairing_delegate, GetCallback(),
                   base::Bind(&BluetoothChromeOSTest::ConnectErrorCallback,
                              base::Unretained(this)));
 
   EXPECT_EQ(1, pairing_delegate.call_count_);
@@ skipping 17 matching lines @@
 
 TEST_F(BluetoothChromeOSTest, PairingCancelledAtPasskey) {
   fake_bluetooth_device_client_->SetSimulationIntervalMs(10);
 
   GetAdapter();
   DiscoverDevices();
 
   // Cancel the pairing after we receive a request for the passkey.
   BluetoothDevice* device = adapter_->GetDevice(
       FakeBluetoothDeviceClient::kRequestPasskeyAddress);
-  ASSERT_TRUE(device != NULL);
+  ASSERT_TRUE(device != nullptr);
   ASSERT_FALSE(device->IsPaired());
 
   TestBluetoothAdapterObserver observer(adapter_);
 
   TestPairingDelegate pairing_delegate;
   device->Connect(&pairing_delegate, GetCallback(),
                   base::Bind(&BluetoothChromeOSTest::ConnectErrorCallback,
                              base::Unretained(this)));
 
   EXPECT_EQ(1, pairing_delegate.call_count_);
@@ skipping 17 matching lines @@
 
 TEST_F(BluetoothChromeOSTest, PairingRejectedAtConfirmation) {
   fake_bluetooth_device_client_->SetSimulationIntervalMs(10);
 
   GetAdapter();
   DiscoverDevices();
 
   // Reject the pairing after we receive a request for passkey confirmation.
   BluetoothDevice* device = adapter_->GetDevice(
       FakeBluetoothDeviceClient::kConfirmPasskeyAddress);
-  ASSERT_TRUE(device != NULL);
+  ASSERT_TRUE(device != nullptr);
   ASSERT_FALSE(device->IsPaired());
 
   TestBluetoothAdapterObserver observer(adapter_);
 
   TestPairingDelegate pairing_delegate;
   device->Connect(&pairing_delegate, GetCallback(),
                   base::Bind(&BluetoothChromeOSTest::ConnectErrorCallback,
                              base::Unretained(this)));
 
   EXPECT_EQ(1, pairing_delegate.call_count_);
@@ skipping 17 matching lines @@
 
 TEST_F(BluetoothChromeOSTest, PairingCancelledAtConfirmation) {
   fake_bluetooth_device_client_->SetSimulationIntervalMs(10);
 
   GetAdapter();
   DiscoverDevices();
 
   // Cancel the pairing after we receive a request for the passkey.
   BluetoothDevice* device = adapter_->GetDevice(
       FakeBluetoothDeviceClient::kConfirmPasskeyAddress);
-  ASSERT_TRUE(device != NULL);
+  ASSERT_TRUE(device != nullptr);
   ASSERT_FALSE(device->IsPaired());
 
   TestBluetoothAdapterObserver observer(adapter_);
 
   TestPairingDelegate pairing_delegate;
   device->Connect(&pairing_delegate, GetCallback(),
                   base::Bind(&BluetoothChromeOSTest::ConnectErrorCallback,
                              base::Unretained(this)));
 
   EXPECT_EQ(1, pairing_delegate.call_count_);
@@ skipping 17 matching lines @@
 
 TEST_F(BluetoothChromeOSTest, PairingCancelledInFlight) {
   fake_bluetooth_device_client_->SetSimulationIntervalMs(10);
 
   GetAdapter();
   DiscoverDevices();
 
   // Cancel the pairing while we're waiting for the remote host.
   BluetoothDevice* device = adapter_->GetDevice(
       FakeBluetoothDeviceClient::kLegacyAutopairAddress);
-  ASSERT_TRUE(device != NULL);
+  ASSERT_TRUE(device != nullptr);
   ASSERT_FALSE(device->IsPaired());
 
   TestBluetoothAdapterObserver observer(adapter_);
 
   TestPairingDelegate pairing_delegate;
   device->Connect(&pairing_delegate, GetCallback(),
                   base::Bind(&BluetoothChromeOSTest::ConnectErrorCallback,
                              base::Unretained(this)));
 
   EXPECT_EQ(0, pairing_delegate.call_count_);
@@ skipping 23 matching lines @@
   adapter_->AddPairingDelegate(
       &pairing_delegate,
       BluetoothAdapter::PAIRING_DELEGATE_PRIORITY_HIGH);
 
   // Requires that we provide a PIN code.
   fake_bluetooth_device_client_->CreateDevice(
       dbus::ObjectPath(FakeBluetoothAdapterClient::kAdapterPath),
       dbus::ObjectPath(FakeBluetoothDeviceClient::kRequestPinCodePath));
   BluetoothDevice* device = adapter_->GetDevice(
       FakeBluetoothDeviceClient::kRequestPinCodeAddress);
-  ASSERT_TRUE(device != NULL);
+  ASSERT_TRUE(device != nullptr);
   ASSERT_FALSE(device->IsPaired());
 
   TestBluetoothAdapterObserver observer(adapter_);
 
   fake_bluetooth_device_client_->SimulatePairing(
       dbus::ObjectPath(FakeBluetoothDeviceClient::kRequestPinCodePath), true,
       GetCallback(), base::Bind(&BluetoothChromeOSTest::DBusErrorCallback,
                                 base::Unretained(this)));
 
   EXPECT_EQ(1, pairing_delegate.call_count_);
@@ skipping 14 matching lines @@
 
   // Make sure the trusted property has been set to true.
   FakeBluetoothDeviceClient::Properties* properties =
       fake_bluetooth_device_client_->GetProperties(
           dbus::ObjectPath(FakeBluetoothDeviceClient::kRequestPinCodePath));
   ASSERT_TRUE(properties->trusted.value());
 
   // No pairing context should remain on the device.
   BluetoothDeviceChromeOS* device_chromeos =
       static_cast<BluetoothDeviceChromeOS*>(device);
-  EXPECT_TRUE(device_chromeos->GetPairing() == NULL);
+  EXPECT_TRUE(device_chromeos->GetPairing() == nullptr);
 }
 
 TEST_F(BluetoothChromeOSTest, IncomingPairConfirmPasskey) {
   fake_bluetooth_device_client_->SetSimulationIntervalMs(10);
 
   GetAdapter();
 
   TestPairingDelegate pairing_delegate;
   adapter_->AddPairingDelegate(
       &pairing_delegate,
       BluetoothAdapter::PAIRING_DELEGATE_PRIORITY_HIGH);
 
   // Requests that we confirm a displayed passkey.
   fake_bluetooth_device_client_->CreateDevice(
       dbus::ObjectPath(FakeBluetoothAdapterClient::kAdapterPath),
       dbus::ObjectPath(FakeBluetoothDeviceClient::kConfirmPasskeyPath));
   BluetoothDevice* device = adapter_->GetDevice(
       FakeBluetoothDeviceClient::kConfirmPasskeyAddress);
-  ASSERT_TRUE(device != NULL);
+  ASSERT_TRUE(device != nullptr);
   ASSERT_FALSE(device->IsPaired());
 
   TestBluetoothAdapterObserver observer(adapter_);
 
   fake_bluetooth_device_client_->SimulatePairing(
       dbus::ObjectPath(FakeBluetoothDeviceClient::kConfirmPasskeyPath), true,
       GetCallback(), base::Bind(&BluetoothChromeOSTest::DBusErrorCallback,
                                 base::Unretained(this)));
 
   EXPECT_EQ(1, pairing_delegate.call_count_);
@@ skipping 15 matching lines @@
 
   // Make sure the trusted property has been set to true.
   FakeBluetoothDeviceClient::Properties* properties =
       fake_bluetooth_device_client_->GetProperties(
           dbus::ObjectPath(FakeBluetoothDeviceClient::kConfirmPasskeyPath));
   ASSERT_TRUE(properties->trusted.value());
 
   // No pairing context should remain on the device.
   BluetoothDeviceChromeOS* device_chromeos =
       static_cast<BluetoothDeviceChromeOS*>(device);
-  EXPECT_TRUE(device_chromeos->GetPairing() == NULL);
+  EXPECT_TRUE(device_chromeos->GetPairing() == nullptr);
 }
 
 TEST_F(BluetoothChromeOSTest, IncomingPairRequestPasskey) {
   fake_bluetooth_device_client_->SetSimulationIntervalMs(10);
 
   GetAdapter();
 
   TestPairingDelegate pairing_delegate;
   adapter_->AddPairingDelegate(
       &pairing_delegate,
       BluetoothAdapter::PAIRING_DELEGATE_PRIORITY_HIGH);
 
   // Requests that we provide a Passkey.
   fake_bluetooth_device_client_->CreateDevice(
       dbus::ObjectPath(FakeBluetoothAdapterClient::kAdapterPath),
       dbus::ObjectPath(FakeBluetoothDeviceClient::kRequestPasskeyPath));
   BluetoothDevice* device = adapter_->GetDevice(
       FakeBluetoothDeviceClient::kRequestPasskeyAddress);
-  ASSERT_TRUE(device != NULL);
+  ASSERT_TRUE(device != nullptr);
   ASSERT_FALSE(device->IsPaired());
 
   TestBluetoothAdapterObserver observer(adapter_);
 
   fake_bluetooth_device_client_->SimulatePairing(
       dbus::ObjectPath(FakeBluetoothDeviceClient::kRequestPasskeyPath), true,
       GetCallback(), base::Bind(&BluetoothChromeOSTest::DBusErrorCallback,
                                 base::Unretained(this)));
 
   EXPECT_EQ(1, pairing_delegate.call_count_);
@@ skipping 14 matching lines @@
 
   // Make sure the trusted property has been set to true.
   FakeBluetoothDeviceClient::Properties* properties =
       fake_bluetooth_device_client_->GetProperties(
           dbus::ObjectPath(FakeBluetoothDeviceClient::kRequestPasskeyPath));
   ASSERT_TRUE(properties->trusted.value());
 
   // No pairing context should remain on the device.
   BluetoothDeviceChromeOS* device_chromeos =
       static_cast<BluetoothDeviceChromeOS*>(device);
-  EXPECT_TRUE(device_chromeos->GetPairing() == NULL);
+  EXPECT_TRUE(device_chromeos->GetPairing() == nullptr);
 }
 
 TEST_F(BluetoothChromeOSTest, IncomingPairJustWorks) {
   fake_bluetooth_device_client_->SetSimulationIntervalMs(10);
 
   GetAdapter();
 
   TestPairingDelegate pairing_delegate;
   adapter_->AddPairingDelegate(
       &pairing_delegate,
       BluetoothAdapter::PAIRING_DELEGATE_PRIORITY_HIGH);
 
   // Uses just-works pairing so, sinec this an incoming pairing, require
   // authorization from the user.
   fake_bluetooth_device_client_->CreateDevice(
       dbus::ObjectPath(FakeBluetoothAdapterClient::kAdapterPath),
       dbus::ObjectPath(FakeBluetoothDeviceClient::kJustWorksPath));
   BluetoothDevice* device = adapter_->GetDevice(
       FakeBluetoothDeviceClient::kJustWorksAddress);
-  ASSERT_TRUE(device != NULL);
+  ASSERT_TRUE(device != nullptr);
   ASSERT_FALSE(device->IsPaired());
 
   TestBluetoothAdapterObserver observer(adapter_);
 
   fake_bluetooth_device_client_->SimulatePairing(
       dbus::ObjectPath(FakeBluetoothDeviceClient::kJustWorksPath), true,
       GetCallback(), base::Bind(&BluetoothChromeOSTest::DBusErrorCallback,
                                 base::Unretained(this)));
 
   EXPECT_EQ(1, pairing_delegate.call_count_);
@@ skipping 14 matching lines @@
 
   // Make sure the trusted property has been set to true.
   FakeBluetoothDeviceClient::Properties* properties =
       fake_bluetooth_device_client_->GetProperties(
           dbus::ObjectPath(FakeBluetoothDeviceClient::kJustWorksPath));
   ASSERT_TRUE(properties->trusted.value());
 
   // No pairing context should remain on the device.
   BluetoothDeviceChromeOS* device_chromeos =
       static_cast<BluetoothDeviceChromeOS*>(device);
-  EXPECT_TRUE(device_chromeos->GetPairing() == NULL);
+  EXPECT_TRUE(device_chromeos->GetPairing() == nullptr);
 }
 
 TEST_F(BluetoothChromeOSTest, IncomingPairRequestPinCodeWithoutDelegate) {
   fake_bluetooth_device_client_->SetSimulationIntervalMs(10);
 
   GetAdapter();
 
   // Requires that we provide a PIN Code, without a pairing delegate,
   // that will be rejected.
   fake_bluetooth_device_client_->CreateDevice(
       dbus::ObjectPath(FakeBluetoothAdapterClient::kAdapterPath),
       dbus::ObjectPath(FakeBluetoothDeviceClient::kRequestPinCodePath));
   BluetoothDevice* device = adapter_->GetDevice(
       FakeBluetoothDeviceClient::kRequestPinCodeAddress);
-  ASSERT_TRUE(device != NULL);
+  ASSERT_TRUE(device != nullptr);
   ASSERT_FALSE(device->IsPaired());
 
   TestBluetoothAdapterObserver observer(adapter_);
 
   fake_bluetooth_device_client_->SimulatePairing(
       dbus::ObjectPath(FakeBluetoothDeviceClient::kRequestPinCodePath), true,
       GetCallback(), base::Bind(&BluetoothChromeOSTest::DBusErrorCallback,
                                 base::Unretained(this)));
 
   message_loop_.Run();
 
   EXPECT_EQ(0, callback_count_);
   EXPECT_EQ(1, error_callback_count_);
   EXPECT_EQ(bluetooth_device::kErrorAuthenticationRejected, last_client_error_);
 
   // No changes should be observer.
   EXPECT_EQ(0, observer.device_changed_count());
 
   EXPECT_FALSE(device->IsPaired());
 
   // No pairing context should remain on the device.
   BluetoothDeviceChromeOS* device_chromeos =
       static_cast<BluetoothDeviceChromeOS*>(device);
-  EXPECT_TRUE(device_chromeos->GetPairing() == NULL);
+  EXPECT_TRUE(device_chromeos->GetPairing() == nullptr);
 }
 
 TEST_F(BluetoothChromeOSTest, IncomingPairConfirmPasskeyWithoutDelegate) {
   fake_bluetooth_device_client_->SetSimulationIntervalMs(10);
 
   GetAdapter();
 
   // Requests that we confirm a displayed passkey, without a pairing delegate,
   // that will be rejected.
   fake_bluetooth_device_client_->CreateDevice(
       dbus::ObjectPath(FakeBluetoothAdapterClient::kAdapterPath),
       dbus::ObjectPath(FakeBluetoothDeviceClient::kConfirmPasskeyPath));
   BluetoothDevice* device = adapter_->GetDevice(
       FakeBluetoothDeviceClient::kConfirmPasskeyAddress);
-  ASSERT_TRUE(device != NULL);
+  ASSERT_TRUE(device != nullptr);
   ASSERT_FALSE(device->IsPaired());
 
   TestBluetoothAdapterObserver observer(adapter_);
 
   fake_bluetooth_device_client_->SimulatePairing(
       dbus::ObjectPath(FakeBluetoothDeviceClient::kConfirmPasskeyPath), true,
       GetCallback(), base::Bind(&BluetoothChromeOSTest::DBusErrorCallback,
                                 base::Unretained(this)));
 
   message_loop_.Run();
 
   EXPECT_EQ(0, callback_count_);
   EXPECT_EQ(1, error_callback_count_);
   EXPECT_EQ(bluetooth_device::kErrorAuthenticationRejected, last_client_error_);
 
   // No changes should be observer.
   EXPECT_EQ(0, observer.device_changed_count());
 
   EXPECT_FALSE(device->IsPaired());
 
   // No pairing context should remain on the device.
   BluetoothDeviceChromeOS* device_chromeos =
       static_cast<BluetoothDeviceChromeOS*>(device);
-  EXPECT_TRUE(device_chromeos->GetPairing() == NULL);
+  EXPECT_TRUE(device_chromeos->GetPairing() == nullptr);
 }
 
 TEST_F(BluetoothChromeOSTest, IncomingPairRequestPasskeyWithoutDelegate) {
   fake_bluetooth_device_client_->SetSimulationIntervalMs(10);
 
   GetAdapter();
 
   // Requests that we provide a displayed passkey, without a pairing delegate,
   // that will be rejected.
   fake_bluetooth_device_client_->CreateDevice(
       dbus::ObjectPath(FakeBluetoothAdapterClient::kAdapterPath),
       dbus::ObjectPath(FakeBluetoothDeviceClient::kRequestPasskeyPath));
   BluetoothDevice* device = adapter_->GetDevice(
       FakeBluetoothDeviceClient::kRequestPasskeyAddress);
-  ASSERT_TRUE(device != NULL);
+  ASSERT_TRUE(device != nullptr);
   ASSERT_FALSE(device->IsPaired());
 
   TestBluetoothAdapterObserver observer(adapter_);
 
   fake_bluetooth_device_client_->SimulatePairing(
       dbus::ObjectPath(FakeBluetoothDeviceClient::kRequestPasskeyPath), true,
       GetCallback(), base::Bind(&BluetoothChromeOSTest::DBusErrorCallback,
                                 base::Unretained(this)));
 
   message_loop_.Run();
 
   EXPECT_EQ(0, callback_count_);
   EXPECT_EQ(1, error_callback_count_);
   EXPECT_EQ(bluetooth_device::kErrorAuthenticationRejected, last_client_error_);
 
   // No changes should be observer.
   EXPECT_EQ(0, observer.device_changed_count());
 
   EXPECT_FALSE(device->IsPaired());
 
   // No pairing context should remain on the device.
   BluetoothDeviceChromeOS* device_chromeos =
       static_cast<BluetoothDeviceChromeOS*>(device);
-  EXPECT_TRUE(device_chromeos->GetPairing() == NULL);
+  EXPECT_TRUE(device_chromeos->GetPairing() == nullptr);
 }
 
 TEST_F(BluetoothChromeOSTest, IncomingPairJustWorksWithoutDelegate) {
   fake_bluetooth_device_client_->SetSimulationIntervalMs(10);
 
   GetAdapter();
 
   // Uses just-works pairing and thus requires authorization for incoming
   // pairings, without a pairing delegate, that will be rejected.
   fake_bluetooth_device_client_->CreateDevice(
       dbus::ObjectPath(FakeBluetoothAdapterClient::kAdapterPath),
       dbus::ObjectPath(FakeBluetoothDeviceClient::kJustWorksPath));
   BluetoothDevice* device = adapter_->GetDevice(
       FakeBluetoothDeviceClient::kJustWorksAddress);
-  ASSERT_TRUE(device != NULL);
+  ASSERT_TRUE(device != nullptr);
   ASSERT_FALSE(device->IsPaired());
 
   TestBluetoothAdapterObserver observer(adapter_);
 
   fake_bluetooth_device_client_->SimulatePairing(
       dbus::ObjectPath(FakeBluetoothDeviceClient::kJustWorksPath), true,
       GetCallback(), base::Bind(&BluetoothChromeOSTest::DBusErrorCallback,
                                 base::Unretained(this)));
 
   message_loop_.Run();
 
   EXPECT_EQ(0, callback_count_);
   EXPECT_EQ(1, error_callback_count_);
   EXPECT_EQ(bluetooth_device::kErrorAuthenticationRejected, last_client_error_);
 
   // No changes should be observer.
   EXPECT_EQ(0, observer.device_changed_count());
 
   EXPECT_FALSE(device->IsPaired());
 
   // No pairing context should remain on the device.
   BluetoothDeviceChromeOS* device_chromeos =
       static_cast<BluetoothDeviceChromeOS*>(device);
-  EXPECT_TRUE(device_chromeos->GetPairing() == NULL);
+  EXPECT_TRUE(device_chromeos->GetPairing() == nullptr);
 }
 
 TEST_F(BluetoothChromeOSTest, RemovePairingDelegateDuringPairing) {
   fake_bluetooth_device_client_->SetSimulationIntervalMs(10);
 
   GetAdapter();
 
   TestPairingDelegate pairing_delegate;
   adapter_->AddPairingDelegate(
       &pairing_delegate,
       BluetoothAdapter::PAIRING_DELEGATE_PRIORITY_HIGH);
 
   // Requests that we provide a Passkey.
   fake_bluetooth_device_client_->CreateDevice(
       dbus::ObjectPath(FakeBluetoothAdapterClient::kAdapterPath),
       dbus::ObjectPath(FakeBluetoothDeviceClient::kRequestPasskeyPath));
   BluetoothDevice* device = adapter_->GetDevice(
       FakeBluetoothDeviceClient::kRequestPasskeyAddress);
-  ASSERT_TRUE(device != NULL);
+  ASSERT_TRUE(device != nullptr);
   ASSERT_FALSE(device->IsPaired());
 
   TestBluetoothAdapterObserver observer(adapter_);
 
   fake_bluetooth_device_client_->SimulatePairing(
       dbus::ObjectPath(FakeBluetoothDeviceClient::kRequestPasskeyPath), true,
       GetCallback(), base::Bind(&BluetoothChromeOSTest::DBusErrorCallback,
                                 base::Unretained(this)));
 
   EXPECT_EQ(1, pairing_delegate.call_count_);
   EXPECT_EQ(1, pairing_delegate.request_passkey_count_);
 
   // A pairing context should now be set on the device.
   BluetoothDeviceChromeOS* device_chromeos =
       static_cast<BluetoothDeviceChromeOS*>(device);
-  ASSERT_TRUE(device_chromeos->GetPairing() != NULL);
+  ASSERT_TRUE(device_chromeos->GetPairing() != nullptr);
 
   // Removing the pairing delegate should remove that pairing context.
   adapter_->RemovePairingDelegate(&pairing_delegate);
 
-  EXPECT_TRUE(device_chromeos->GetPairing() == NULL);
+  EXPECT_TRUE(device_chromeos->GetPairing() == nullptr);
 
   // Set the Passkey, this should now have no effect since the pairing has
   // been, in-effect, cancelled
   device->SetPasskey(1234);
 
   EXPECT_EQ(0, callback_count_);
   EXPECT_EQ(0, error_callback_count_);
   EXPECT_EQ(0, observer.device_changed_count());
 
   EXPECT_FALSE(device->IsPaired());
 }
 
 TEST_F(BluetoothChromeOSTest, DeviceId) {
   GetAdapter();
 
   // Use the built-in paired device for this test, grab its Properties
   // structure so we can adjust the underlying modalias property.
   BluetoothDevice* device = adapter_->GetDevice(
       FakeBluetoothDeviceClient::kPairedDeviceAddress);
   FakeBluetoothDeviceClient::Properties* properties =
       fake_bluetooth_device_client_->GetProperties(
           dbus::ObjectPath(FakeBluetoothDeviceClient::kPairedDevicePath));
 
-  ASSERT_TRUE(device != NULL);
-  ASSERT_TRUE(properties != NULL);
+  ASSERT_TRUE(device != nullptr);
+  ASSERT_TRUE(properties != nullptr);
 
   // Valid USB IF-assigned identifier.
   ASSERT_EQ("usb:v05ACp030Dd0306", properties->modalias.value());
 
   EXPECT_EQ(BluetoothDevice::VENDOR_ID_USB, device->GetVendorIDSource());
   EXPECT_EQ(0x05ac, device->GetVendorID());
   EXPECT_EQ(0x030d, device->GetProductID());
   EXPECT_EQ(0x0306, device->GetDeviceID());
 
   // Valid Bluetooth SIG-assigned identifier.
@@ skipping 43 matching lines @@
   EXPECT_EQ(unknown_power, conn_info.rssi);
   EXPECT_EQ(unknown_power, conn_info.transmit_power);
   EXPECT_EQ(unknown_power, conn_info.max_transmit_power);
 }
 
 TEST_F(BluetoothChromeOSTest, GetConnectionInfoForConnectedDevice) {
   GetAdapter();
   BluetoothDevice* device =
       adapter_->GetDevice(FakeBluetoothDeviceClient::kPairedDeviceAddress);
 
-  device->Connect(NULL, GetCallback(),
+  device->Connect(nullptr, GetCallback(),
                   base::Bind(&BluetoothChromeOSTest::ConnectErrorCallback,
                              base::Unretained(this)));
   EXPECT_TRUE(device->IsConnected());
 
   // Calling GetConnectionInfo for a connected device should return valid
   // results.
   fake_bluetooth_device_client_->UpdateConnectionInfo(-10, 3, 4);
   BluetoothDevice::ConnectionInfo conn_info;
   device->GetConnectionInfo(base::Bind(&SaveConnectionInfo, &conn_info));
   EXPECT_EQ(-10, conn_info.rssi);
@@ skipping 75 matching lines @@
       audio_sink_options,
       base::Bind(&BluetoothChromeOSTest::AudioSinkAcquiredCallback,
                  base::Unretained(this)),
       base::Bind(&BluetoothChromeOSTest::AudioSinkErrorCallback,
                  base::Unretained(this)));
   EXPECT_EQ(0, callback_count_);
   EXPECT_EQ(1, error_callback_count_--) << "RegisterAudioSink error";
 
   BluetoothAdapterChromeOS* adapter_chrome_os =
       static_cast<BluetoothAdapterChromeOS*>(adapter_.get());
-  EXPECT_EQ(NULL, adapter_chrome_os->GetDeviceWithPath(dbus::ObjectPath("")));
+  EXPECT_EQ(nullptr,
+            adapter_chrome_os->GetDeviceWithPath(dbus::ObjectPath("")));
 
   // Notify methods presume objects exist that are owned by the adapter and
   // destroyed in Shutdown(). Mocks are not attempted here that won't exist,
   // as verified below by EXPECT_EQ(0U, adapter_->GetDevices().size());
   // NotifyDeviceChanged
   // NotifyGattServiceAdded
   // NotifyGattServiceRemoved
   // NotifyGattServiceChanged
   // NotifyGattDiscoveryComplete
   // NotifyGattCharacteristicAdded
   // NotifyGattCharacteristicRemoved
   // NotifyGattDescriptorAdded
   // NotifyGattDescriptorRemoved
   // NotifyGattCharacteristicValueChanged
   // NotifyGattDescriptorValueChanged
 
   EXPECT_EQ(dbus::ObjectPath(""), adapter_chrome_os->object_path());
 
-  adapter_profile_ = NULL;
+  adapter_profile_ = nullptr;
 
   FakeBluetoothProfileServiceProviderDelegate profile_delegate;
   adapter_chrome_os->UseProfile(
       BluetoothUUID(), dbus::ObjectPath(""),
       BluetoothProfileManagerClient::Options(), &profile_delegate,
       base::Bind(&BluetoothChromeOSTest::ProfileRegisteredCallback,
                  base::Unretained(this)),
       base::Bind(&BluetoothChromeOSTest::ErrorCompletionCallback,
                  base::Unretained(this)));
 
@@ skipping 55 matching lines @@
   adapter_chrome_os->RemoveDiscoverySession(nullptr, GetCallback(),
                                             GetErrorCallback());
   EXPECT_EQ(0, callback_count_) << "RemoveDiscoverySession error";
   EXPECT_EQ(1, error_callback_count_--) << "RemoveDiscoverySession error";
 
   // OnStartDiscovery tested in Shutdown_OnStartDiscovery
   // OnStartDiscoveryError tested in Shutdown_OnStartDiscoveryError
   // OnStopDiscovery tested in Shutdown_OnStopDiscovery
   // OnStopDiscoveryError tested in Shutdown_OnStopDiscoveryError
 
-  adapter_profile_ = NULL;
+  adapter_profile_ = nullptr;
 
   // OnRegisterProfile SetProfileDelegate, OnRegisterProfileError, require
   // UseProfile to be set first, do so again here just before calling them.
   adapter_chrome_os->UseProfile(
       BluetoothUUID(), dbus::ObjectPath(""),
       BluetoothProfileManagerClient::Options(), &profile_delegate,
       base::Bind(&BluetoothChromeOSTest::ProfileRegisteredCallback,
                  base::Unretained(this)),
       base::Bind(&BluetoothChromeOSTest::ErrorCompletionCallback,
                  base::Unretained(this)));
@@ skipping 126 matching lines @@
   adapter_->Shutdown();
   adapter_chrome_os->OnStopDiscoveryError(GetErrorCallback(), "", "");
 
   // 1 error reported to RemoveDiscoverySession because of OnStopDiscoveryError,
   // and kNumberOfDiscoverySessions errors queued with AddDiscoverySession.
   EXPECT_EQ(0, callback_count_);
   EXPECT_EQ(1 + kNumberOfDiscoverySessions, error_callback_count_);
 }
 
 }  // namespace chromeos