device: Change auto to not deduce raw pointers.

device/bluetooth/bluez/bluetooth_bluez_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 <stddef.h>
 #include <stdint.h>
 
 #include <memory>
 #include <utility>
 
@@ skipping 38 matching lines @@
 // connection info to the bound argument.
 void SaveConnectionInfo(BluetoothDevice::ConnectionInfo* out,
                         const BluetoothDevice::ConnectionInfo& conn_info) {
   *out = conn_info;
 }
 
 // Find |address| in |devices|, if found returns the index otherwise returns -1.
 int GetDeviceIndexByAddress(const BluetoothAdapter::DeviceList& devices,
                             const char* address) {
   int idx = -1;
-  for (auto& device : devices) {
+  for (auto* device : devices) {
     ++idx;
     if (device->GetAddress().compare(address) == 0)
       return idx;
   }
   return -1;
 }
 
 class FakeBluetoothProfileServiceProviderDelegate
     : public bluez::BluetoothProfileServiceProvider::Delegate {
  public:
@@ skipping 1390 matching lines @@
   EXPECT_EQ(2, callback_count_);
   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());
   ASSERT_TRUE(df->Equals(*discovery_sessions_[0]->GetDiscoveryFilter()));
 
-  auto filter = fake_bluetooth_adapter_client_->GetDiscoveryFilter();
+  auto* filter = fake_bluetooth_adapter_client_->GetDiscoveryFilter();
   EXPECT_NE(nullptr, filter);
   EXPECT_EQ("le", *filter->transport);
   EXPECT_EQ(-60, *filter->rssi);
   EXPECT_EQ(nullptr, filter->pathloss.get());
   std::vector<std::string> uuids = *filter->uuids;
   EXPECT_NE(uuids.end(), std::find(uuids.begin(), uuids.end(), "1000"));
 
   discovery_sessions_[0]->Stop(
       base::Bind(&BluetoothBlueZTest::Callback, base::Unretained(this)),
       base::Bind(&BluetoothBlueZTest::ErrorCallback, base::Unretained(this)));
@@ skipping 43 matching lines @@
 
   message_loop_.Run();
 
   EXPECT_EQ(1, error_callback_count_);
   error_callback_count_ = 0;
 
   ASSERT_TRUE(adapter_->IsPowered());
   ASSERT_FALSE(adapter_->IsDiscovering());
   ASSERT_EQ((size_t)0, discovery_sessions_.size());
 
-  auto filter = fake_bluetooth_adapter_client_->GetDiscoveryFilter();
+  auto* filter = fake_bluetooth_adapter_client_->GetDiscoveryFilter();
   EXPECT_EQ(nullptr, filter);
 }
 
 // This test queues two requests to StartDiscovery with pre set filter. This
 // should result in SetDiscoveryFilter, then StartDiscovery, and SetDiscovery
 // DBus calls
 TEST_F(BluetoothBlueZTest, QueuedSetDiscoveryFilterBeforeStartDiscovery) {
   // Test a simulated discovery session.
   fake_bluetooth_device_client_->SetSimulationIntervalMs(10);
   GetAdapter();
@@ skipping 43 matching lines @@
   callback_count_ = 0;
 
   ASSERT_TRUE(adapter_->IsPowered());
   ASSERT_TRUE(adapter_->IsDiscovering());
   ASSERT_EQ((size_t)2, discovery_sessions_.size());
   ASSERT_TRUE(discovery_sessions_[0]->IsActive());
   ASSERT_TRUE(df->Equals(*discovery_sessions_[0]->GetDiscoveryFilter()));
   ASSERT_TRUE(discovery_sessions_[1]->IsActive());
   ASSERT_TRUE(df2->Equals(*discovery_sessions_[1]->GetDiscoveryFilter()));
 
-  auto filter = fake_bluetooth_adapter_client_->GetDiscoveryFilter();
+  auto* filter = fake_bluetooth_adapter_client_->GetDiscoveryFilter();
   EXPECT_NE(nullptr, filter);
   EXPECT_EQ("auto", *filter->transport);
   EXPECT_EQ(-65, *filter->rssi);
   EXPECT_EQ(nullptr, filter->pathloss.get());
   auto uuids = *filter->uuids;
   EXPECT_NE(uuids.end(), std::find(uuids.begin(), uuids.end(), "1000"));
   EXPECT_NE(uuids.end(), std::find(uuids.begin(), uuids.end(), "1002"));
 
   discovery_sessions_[0]->Stop(
       base::Bind(&BluetoothBlueZTest::Callback, base::Unretained(this)),
@@ skipping 83 matching lines @@
   // Second request should succeed
   EXPECT_EQ(1, callback_count_);
   EXPECT_EQ(0, error_callback_count_);
   callback_count_ = 0;
 
   ASSERT_TRUE(adapter_->IsDiscovering());
   ASSERT_EQ((size_t)1, discovery_sessions_.size());
   ASSERT_TRUE(discovery_sessions_[0]->IsActive());
   ASSERT_TRUE(df2->Equals(*discovery_sessions_[0]->GetDiscoveryFilter()));
 
-  auto filter = fake_bluetooth_adapter_client_->GetDiscoveryFilter();
+  auto* filter = fake_bluetooth_adapter_client_->GetDiscoveryFilter();
   EXPECT_NE(nullptr, filter);
   EXPECT_EQ("bredr", *filter->transport);
   EXPECT_EQ(-65, *filter->rssi);
   EXPECT_EQ(nullptr, filter->pathloss.get());
   auto uuids = *filter->uuids;
   EXPECT_NE(uuids.end(), std::find(uuids.begin(), uuids.end(), "1002"));
 
   discovery_sessions_[0]->Stop(
       base::Bind(&BluetoothBlueZTest::Callback, base::Unretained(this)),
       base::Bind(&BluetoothBlueZTest::ErrorCallback, base::Unretained(this)));
@@ skipping 36 matching lines @@
   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 null_instance = std::unique_ptr<BluetoothDiscoveryFilter>();
   null_instance.reset();
   ASSERT_EQ(discovery_sessions_[0]->GetDiscoveryFilter(), null_instance.get());
 
-  auto filter = fake_bluetooth_adapter_client_->GetDiscoveryFilter();
+  auto* filter = fake_bluetooth_adapter_client_->GetDiscoveryFilter();
   EXPECT_EQ(nullptr, filter);
 
   BluetoothDiscoveryFilter* df =
       new BluetoothDiscoveryFilter(device::BLUETOOTH_TRANSPORT_LE);
   df->SetRSSI(-60);
   df->AddUUID(BluetoothUUID("1000"));
   std::unique_ptr<BluetoothDiscoveryFilter> discovery_filter(df);
 
   discovery_sessions_[0]->SetDiscoveryFilter(
       std::move(discovery_filter),
@@ skipping 79 matching lines @@
         base::Bind(&BluetoothBlueZTest::DiscoverySessionCallback,
                    base::Unretained(this)),
         base::Bind(&BluetoothBlueZTest::ErrorCallback, base::Unretained(this)));
 
     message_loop_.Run();
 
     if (i == 0) {
       EXPECT_EQ(1, observer.discovering_changed_count());
       observer.Reset();
 
-      auto filter = fake_bluetooth_adapter_client_->GetDiscoveryFilter();
+      auto* filter = fake_bluetooth_adapter_client_->GetDiscoveryFilter();
       EXPECT_EQ("le", *filter->transport);
       EXPECT_EQ(-85, *filter->rssi);
       EXPECT_EQ(nullptr, filter->pathloss.get());
       std::vector<std::string> uuids = *filter->uuids;
       EXPECT_NE(uuids.end(), std::find(uuids.begin(), uuids.end(), "1000"));
     } else if (i == 1) {
-      auto filter = fake_bluetooth_adapter_client_->GetDiscoveryFilter();
+      auto* filter = fake_bluetooth_adapter_client_->GetDiscoveryFilter();
       EXPECT_EQ("le", *filter->transport);
       EXPECT_EQ(-85, *filter->rssi);
       EXPECT_EQ(nullptr, filter->pathloss.get());
       std::vector<std::string> uuids = *filter->uuids;
       EXPECT_NE(uuids.end(), std::find(uuids.begin(), uuids.end(), "1000"));
       EXPECT_NE(uuids.end(), std::find(uuids.begin(), uuids.end(), "1001"));
       EXPECT_NE(uuids.end(), std::find(uuids.begin(), uuids.end(), "1020"));
     } else if (i == 2) {
-      auto filter = fake_bluetooth_adapter_client_->GetDiscoveryFilter();
+      auto* filter = fake_bluetooth_adapter_client_->GetDiscoveryFilter();
       EXPECT_EQ("le", *filter->transport);
       EXPECT_EQ(-85, *filter->rssi);
       EXPECT_EQ(nullptr, filter->pathloss.get());
       std::vector<std::string> uuids = *filter->uuids;
       EXPECT_NE(uuids.end(), std::find(uuids.begin(), uuids.end(), "1000"));
       EXPECT_NE(uuids.end(), std::find(uuids.begin(), uuids.end(), "1001"));
       EXPECT_NE(uuids.end(), std::find(uuids.begin(), uuids.end(), "1003"));
       EXPECT_NE(uuids.end(), std::find(uuids.begin(), uuids.end(), "1020"));
     }
   }
 
   // the success callback should have been called 3 times and the adapter should
   // be discovering.
   EXPECT_EQ(3, callback_count_);
   EXPECT_EQ(0, error_callback_count_);
   EXPECT_TRUE(adapter_->IsDiscovering());
   ASSERT_EQ((size_t)3, discovery_sessions_.size());
 
   callback_count_ = 0;
   // Request to stop discovery twice.
   for (int i = 0; i < 2; i++) {
     discovery_sessions_[i]->Stop(
         base::Bind(&BluetoothBlueZTest::Callback, base::Unretained(this)),
         base::Bind(&BluetoothBlueZTest::ErrorCallback, base::Unretained(this)));
     message_loop_.Run();
 
     if (i == 0) {
-      auto filter = fake_bluetooth_adapter_client_->GetDiscoveryFilter();
+      auto* filter = fake_bluetooth_adapter_client_->GetDiscoveryFilter();
       EXPECT_EQ("le", *filter->transport);
       EXPECT_EQ(-65, *filter->rssi);
       EXPECT_EQ(nullptr, filter->pathloss.get());
       std::vector<std::string> uuids = *filter->uuids;
       EXPECT_EQ(3UL, uuids.size());
       EXPECT_EQ(uuids.end(), std::find(uuids.begin(), uuids.end(), "1000"));
       EXPECT_NE(uuids.end(), std::find(uuids.begin(), uuids.end(), "1001"));
       EXPECT_NE(uuids.end(), std::find(uuids.begin(), uuids.end(), "1003"));
       EXPECT_NE(uuids.end(), std::find(uuids.begin(), uuids.end(), "1020"));
     } else if (i == 1) {
-      auto filter = fake_bluetooth_adapter_client_->GetDiscoveryFilter();
+      auto* filter = fake_bluetooth_adapter_client_->GetDiscoveryFilter();
       EXPECT_EQ("le", *filter->transport);
       EXPECT_EQ(-65, *filter->rssi);
       EXPECT_EQ(nullptr, filter->pathloss.get());
       std::vector<std::string> uuids = *filter->uuids;
       EXPECT_EQ(2UL, uuids.size());
       EXPECT_EQ(uuids.end(), std::find(uuids.begin(), uuids.end(), "1000"));
       EXPECT_EQ(uuids.end(), std::find(uuids.begin(), uuids.end(), "1001"));
       EXPECT_NE(uuids.end(), std::find(uuids.begin(), uuids.end(), "1003"));
       EXPECT_NE(uuids.end(), std::find(uuids.begin(), uuids.end(), "1020"));
     } else if (i == 2) {
-      auto filter = fake_bluetooth_adapter_client_->GetDiscoveryFilter();
+      auto* filter = fake_bluetooth_adapter_client_->GetDiscoveryFilter();
       EXPECT_EQ("le", *filter->transport);
       EXPECT_EQ(-65, *filter->rssi);
       EXPECT_EQ(nullptr, filter->pathloss.get());
       std::vector<std::string> uuids = *filter->uuids;
       EXPECT_EQ(0UL, uuids.size());
     }
   }
 
   // The success callback should have been called 2 times and the adapter should
   // still be discovering.
@@ skipping 35 matching lines @@
     adapter_->StartDiscoverySessionWithFilter(
         std::move(discovery_filter),
         base::Bind(&BluetoothBlueZTest::DiscoverySessionCallback,
                    base::Unretained(this)),
         base::Bind(&BluetoothBlueZTest::ErrorCallback, base::Unretained(this)));
 
     // each result in 1 requests.
     message_loop_.Run();
 
     if (i == 0) {
-      auto filter = fake_bluetooth_adapter_client_->GetDiscoveryFilter();
+      auto* filter = fake_bluetooth_adapter_client_->GetDiscoveryFilter();
       EXPECT_EQ("le", *filter->transport);
       EXPECT_EQ(-85, *filter->rssi);
       EXPECT_EQ(nullptr, filter->pathloss.get());
       std::vector<std::string> uuids = *filter->uuids;
       EXPECT_NE(uuids.end(), std::find(uuids.begin(), uuids.end(), "1000"));
       EXPECT_NE(uuids.end(), std::find(uuids.begin(), uuids.end(), "1003"));
       EXPECT_NE(uuids.end(), std::find(uuids.begin(), uuids.end(), "1020"));
     } else if (i == 1 || i == 2) {
-      auto filter = fake_bluetooth_adapter_client_->GetDiscoveryFilter();
+      auto* filter = fake_bluetooth_adapter_client_->GetDiscoveryFilter();
       EXPECT_EQ("le", *filter->transport);
       EXPECT_EQ(-85, *filter->rssi);
       EXPECT_EQ(nullptr, filter->pathloss.get());
       std::vector<std::string> uuids = *filter->uuids;
       EXPECT_NE(uuids.end(), std::find(uuids.begin(), uuids.end(), "1000"));
       EXPECT_NE(uuids.end(), std::find(uuids.begin(), uuids.end(), "1001"));
       EXPECT_NE(uuids.end(), std::find(uuids.begin(), uuids.end(), "1003"));
       EXPECT_NE(uuids.end(), std::find(uuids.begin(), uuids.end(), "1020"));
     }
   }
@@ skipping 24 matching lines @@
   // no longer be discovering.
   EXPECT_EQ(4, callback_count_);
   EXPECT_EQ(0, error_callback_count_);
   EXPECT_FALSE(adapter_->IsDiscovering());
   EXPECT_EQ(1, observer.discovering_changed_count());
 
   // All discovery sessions should be inactive.
   for (int i = 0; i < 6; i++)
     EXPECT_FALSE(discovery_sessions_[i]->IsActive());
 
-  auto filter = fake_bluetooth_adapter_client_->GetDiscoveryFilter();
+  auto* filter = fake_bluetooth_adapter_client_->GetDiscoveryFilter();
   EXPECT_EQ(nullptr, filter);
 }
 
 // This unit test asserts that filter merging logic works correctly for filtered
 // discovery requests done via the BluetoothAdapter.
 TEST_F(BluetoothBlueZTest, SetDiscoveryFilterMergingTest) {
   GetAdapter();
   adapter_->SetPowered(
       true, base::Bind(&BluetoothBlueZTest::Callback, base::Unretained(this)),
       base::Bind(&BluetoothBlueZTest::ErrorCallback, base::Unretained(this)));
 
   BluetoothDiscoveryFilter* df =
       new BluetoothDiscoveryFilter(device::BLUETOOTH_TRANSPORT_LE);
   df->SetRSSI(-15);
   df->AddUUID(BluetoothUUID("1000"));
   std::unique_ptr<BluetoothDiscoveryFilter> discovery_filter(df);
 
   adapter_->StartDiscoverySessionWithFilter(
       std::move(discovery_filter),
       base::Bind(&BluetoothBlueZTest::DiscoverySessionCallback,
                  base::Unretained(this)),
       base::Bind(&BluetoothBlueZTest::ErrorCallback, base::Unretained(this)));
 
   message_loop_.Run();
 
-  auto filter = fake_bluetooth_adapter_client_->GetDiscoveryFilter();
+  auto* filter = fake_bluetooth_adapter_client_->GetDiscoveryFilter();
   EXPECT_EQ("le", *filter->transport);
   EXPECT_EQ(-15, *filter->rssi);
   EXPECT_EQ(nullptr, filter->pathloss.get());
   std::vector<std::string> uuids = *filter->uuids;
   EXPECT_NE(uuids.end(), std::find(uuids.begin(), uuids.end(), "1000"));
 
   df = new BluetoothDiscoveryFilter(device::BLUETOOTH_TRANSPORT_LE);
   df->SetRSSI(-60);
   df->AddUUID(BluetoothUUID("1020"));
   df->AddUUID(BluetoothUUID("1001"));
@@ skipping 2425 matching lines @@
   adapter_->Shutdown();
   adapter_bluez->OnStopDiscoveryError(GetDiscoveryErrorCallback(), "", "");
 
   // 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 bluez