device/bluetooth: split out transport enum

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>
 
 #include "base/bind_helpers.h"
 #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 "dbus/object_path.h"
 #include "device/bluetooth/bluetooth_adapter.h"
 #include "device/bluetooth/bluetooth_adapter_factory.h"
+#include "device/bluetooth/bluetooth_common.h"
 #include "device/bluetooth/bluetooth_device.h"
 #include "device/bluetooth/bluetooth_discovery_session.h"
 #include "device/bluetooth/bluez/bluetooth_adapter_bluez.h"
 #include "device/bluetooth/bluez/bluetooth_device_bluez.h"
 #include "device/bluetooth/bluez/bluetooth_pairing_bluez.h"
 #include "device/bluetooth/dbus/bluez_dbus_manager.h"
 #include "device/bluetooth/dbus/fake_bluetooth_adapter_client.h"
 #include "device/bluetooth/dbus/fake_bluetooth_agent_manager_client.h"
 #include "device/bluetooth/dbus/fake_bluetooth_device_client.h"
 #include "device/bluetooth/dbus/fake_bluetooth_gatt_service_client.h"
@@ skipping 1405 matching lines @@
   EXPECT_FALSE(adapter_->IsDiscovering());
 }
 
 TEST_F(BluetoothBlueZTest, SetDiscoveryFilterBeforeStartDiscovery) {
   // Test a simulated discovery session.
   fake_bluetooth_device_client_->SetSimulationIntervalMs(10);
   GetAdapter();
 
   TestBluetoothAdapterObserver observer(adapter_);
 
-  BluetoothDiscoveryFilter* df = new BluetoothDiscoveryFilter(
-      BluetoothDiscoveryFilter::Transport::TRANSPORT_LE);
+  BluetoothDiscoveryFilter* df =
+      new BluetoothDiscoveryFilter(device::BLUETOOTH_TRANSPORT_LE);
   df->SetRSSI(-60);
   df->AddUUID(BluetoothUUID("1000"));
   std::unique_ptr<BluetoothDiscoveryFilter> discovery_filter(df);
 
   adapter_->SetPowered(
       true, base::Bind(&BluetoothBlueZTest::Callback, base::Unretained(this)),
       base::Bind(&BluetoothBlueZTest::ErrorCallback, base::Unretained(this)));
   adapter_->StartDiscoverySessionWithFilter(
       std::move(discovery_filter),
       base::Bind(&BluetoothBlueZTest::DiscoverySessionCallback,
@@ skipping 38 matching lines @@
   EXPECT_EQ(nullptr, filter);
 }
 
 TEST_F(BluetoothBlueZTest, SetDiscoveryFilterBeforeStartDiscoveryFail) {
   // Test a simulated discovery session.
   fake_bluetooth_device_client_->SetSimulationIntervalMs(10);
   GetAdapter();
 
   TestBluetoothAdapterObserver observer(adapter_);
 
-  BluetoothDiscoveryFilter* df = new BluetoothDiscoveryFilter(
-      BluetoothDiscoveryFilter::Transport::TRANSPORT_LE);
+  BluetoothDiscoveryFilter* df =
+      new BluetoothDiscoveryFilter(device::BLUETOOTH_TRANSPORT_LE);
   df->SetRSSI(-60);
   df->AddUUID(BluetoothUUID("1000"));
   std::unique_ptr<BluetoothDiscoveryFilter> discovery_filter(df);
 
   adapter_->SetPowered(
       true, base::Bind(&BluetoothBlueZTest::Callback, base::Unretained(this)),
       base::Bind(&BluetoothBlueZTest::ErrorCallback, base::Unretained(this)));
   EXPECT_EQ(1, callback_count_);
   callback_count_ = 0;
 
@@ skipping 21 matching lines @@
 // 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();
 
   TestBluetoothAdapterObserver observer(adapter_);
 
-  BluetoothDiscoveryFilter* df = new BluetoothDiscoveryFilter(
-      BluetoothDiscoveryFilter::Transport::TRANSPORT_LE);
+  BluetoothDiscoveryFilter* df =
+      new BluetoothDiscoveryFilter(device::BLUETOOTH_TRANSPORT_LE);
   df->SetRSSI(-60);
   df->AddUUID(BluetoothUUID("1000"));
   std::unique_ptr<BluetoothDiscoveryFilter> discovery_filter(df);
 
-  BluetoothDiscoveryFilter* df2 = new BluetoothDiscoveryFilter(
-      BluetoothDiscoveryFilter::Transport::TRANSPORT_CLASSIC);
+  BluetoothDiscoveryFilter* df2 =
+      new BluetoothDiscoveryFilter(device::BLUETOOTH_TRANSPORT_CLASSIC);
   df2->SetRSSI(-65);
   df2->AddUUID(BluetoothUUID("1002"));
   std::unique_ptr<BluetoothDiscoveryFilter> discovery_filter2(df2);
 
   adapter_->SetPowered(
       true, base::Bind(&BluetoothBlueZTest::Callback, base::Unretained(this)),
       base::Bind(&BluetoothBlueZTest::ErrorCallback, base::Unretained(this)));
 
   EXPECT_EQ(1, callback_count_);
   EXPECT_EQ(0, error_callback_count_);
@@ skipping 67 matching lines @@
 // 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(BluetoothBlueZTest, QueuedSetDiscoveryFilterBeforeStartDiscoveryFail) {
   // Test a simulated discovery session.
   fake_bluetooth_device_client_->SetSimulationIntervalMs(10);
   GetAdapter();
 
   TestBluetoothAdapterObserver observer(adapter_);
 
-  BluetoothDiscoveryFilter* df = new BluetoothDiscoveryFilter(
-      BluetoothDiscoveryFilter::Transport::TRANSPORT_LE);
+  BluetoothDiscoveryFilter* df =
+      new BluetoothDiscoveryFilter(device::BLUETOOTH_TRANSPORT_LE);
   df->SetRSSI(-60);
   df->AddUUID(BluetoothUUID("1000"));
   std::unique_ptr<BluetoothDiscoveryFilter> discovery_filter(df);
 
-  BluetoothDiscoveryFilter* df2 = new BluetoothDiscoveryFilter(
-      BluetoothDiscoveryFilter::Transport::TRANSPORT_CLASSIC);
+  BluetoothDiscoveryFilter* df2 =
+      new BluetoothDiscoveryFilter(device::BLUETOOTH_TRANSPORT_CLASSIC);
   df2->SetRSSI(-65);
   df2->AddUUID(BluetoothUUID("1002"));
   std::unique_ptr<BluetoothDiscoveryFilter> discovery_filter2(df2);
 
   adapter_->SetPowered(
       true, base::Bind(&BluetoothBlueZTest::Callback, base::Unretained(this)),
       base::Bind(&BluetoothBlueZTest::ErrorCallback, base::Unretained(this)));
 
   EXPECT_EQ(1, callback_count_);
   EXPECT_EQ(0, error_callback_count_);
@@ skipping 91 matching lines @@
   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();
   EXPECT_EQ(nullptr, filter);
 
-  BluetoothDiscoveryFilter* df = new BluetoothDiscoveryFilter(
-      BluetoothDiscoveryFilter::Transport::TRANSPORT_LE);
+  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),
       base::Bind(&BluetoothBlueZTest::Callback, base::Unretained(this)),
       base::Bind(&BluetoothBlueZTest::ErrorCallback, base::Unretained(this)));
 
   message_loop_.Run();
@@ skipping 42 matching lines @@
   EXPECT_EQ(0, error_callback_count_);
   EXPECT_TRUE(adapter_->IsPowered());
   callback_count_ = 0;
 
   TestBluetoothAdapterObserver observer(adapter_);
 
   // Request device discovery with pre-set filter 3 times.
   for (int i = 0; i < 3; i++) {
     std::unique_ptr<BluetoothDiscoveryFilter> discovery_filter;
     if (i == 0) {
-      BluetoothDiscoveryFilter* df = new BluetoothDiscoveryFilter(
-          BluetoothDiscoveryFilter::Transport::TRANSPORT_LE);
+      BluetoothDiscoveryFilter* df =
+          new BluetoothDiscoveryFilter(device::BLUETOOTH_TRANSPORT_LE);
       df->SetRSSI(-85);
       df->AddUUID(BluetoothUUID("1000"));
       discovery_filter.reset(df);
     } else if (i == 1) {
-      BluetoothDiscoveryFilter* df = new BluetoothDiscoveryFilter(
-          BluetoothDiscoveryFilter::Transport::TRANSPORT_LE);
+      BluetoothDiscoveryFilter* df =
+          new BluetoothDiscoveryFilter(device::BLUETOOTH_TRANSPORT_LE);
       df->SetRSSI(-60);
       df->AddUUID(BluetoothUUID("1020"));
       df->AddUUID(BluetoothUUID("1001"));
       discovery_filter.reset(df);
     } else if (i == 2) {
-      BluetoothDiscoveryFilter* df = new BluetoothDiscoveryFilter(
-          BluetoothDiscoveryFilter::Transport::TRANSPORT_LE);
+      BluetoothDiscoveryFilter* df =
+          new BluetoothDiscoveryFilter(device::BLUETOOTH_TRANSPORT_LE);
       df->SetRSSI(-65);
       df->AddUUID(BluetoothUUID("1020"));
       df->AddUUID(BluetoothUUID("1003"));
       discovery_filter.reset(df);
     }
 
     adapter_->StartDiscoverySessionWithFilter(
         std::move(discovery_filter),
         base::Bind(&BluetoothBlueZTest::DiscoverySessionCallback,
                    base::Unretained(this)),
@@ skipping 89 matching lines @@
   EXPECT_FALSE(discovery_sessions_[1]->IsActive());
   EXPECT_TRUE(discovery_sessions_[2]->IsActive());
 
   callback_count_ = 0;
 
   // Request device discovery 3 times.
   for (int i = 0; i < 3; i++) {
     std::unique_ptr<BluetoothDiscoveryFilter> discovery_filter;
 
     if (i == 0) {
-      BluetoothDiscoveryFilter* df = new BluetoothDiscoveryFilter(
-          BluetoothDiscoveryFilter::Transport::TRANSPORT_LE);
+      BluetoothDiscoveryFilter* df =
+          new BluetoothDiscoveryFilter(device::BLUETOOTH_TRANSPORT_LE);
       df->SetRSSI(-85);
       df->AddUUID(BluetoothUUID("1000"));
       discovery_filter.reset(df);
     } else if (i == 1) {
-      BluetoothDiscoveryFilter* df = new BluetoothDiscoveryFilter(
-          BluetoothDiscoveryFilter::Transport::TRANSPORT_LE);
+      BluetoothDiscoveryFilter* df =
+          new BluetoothDiscoveryFilter(device::BLUETOOTH_TRANSPORT_LE);
       df->SetRSSI(-60);
       df->AddUUID(BluetoothUUID("1020"));
       df->AddUUID(BluetoothUUID("1001"));
       discovery_filter.reset(df);
     } else if (i == 2) {
-      BluetoothDiscoveryFilter* df = new BluetoothDiscoveryFilter(
-          BluetoothDiscoveryFilter::Transport::TRANSPORT_LE);
+      BluetoothDiscoveryFilter* df =
+          new BluetoothDiscoveryFilter(device::BLUETOOTH_TRANSPORT_LE);
       df->SetRSSI(-65);
       df->AddUUID(BluetoothUUID("1020"));
       df->AddUUID(BluetoothUUID("1003"));
       discovery_filter.reset(df);
     }
 
     adapter_->StartDiscoverySessionWithFilter(
         std::move(discovery_filter),
         base::Bind(&BluetoothBlueZTest::DiscoverySessionCallback,
                    base::Unretained(this)),
@@ skipping 62 matching lines @@
 }
 
 // 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(
-      BluetoothDiscoveryFilter::Transport::TRANSPORT_LE);
+  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();
   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(
-      BluetoothDiscoveryFilter::Transport::TRANSPORT_LE);
+  df = new BluetoothDiscoveryFilter(device::BLUETOOTH_TRANSPORT_LE);
   df->SetRSSI(-60);
   df->AddUUID(BluetoothUUID("1020"));
   df->AddUUID(BluetoothUUID("1001"));
   discovery_filter = std::unique_ptr<BluetoothDiscoveryFilter>(df);
 
   adapter_->StartDiscoverySessionWithFilter(
       std::move(discovery_filter),
       base::Bind(&BluetoothBlueZTest::DiscoverySessionCallback,
                  base::Unretained(this)),
       base::Bind(&BluetoothBlueZTest::ErrorCallback, base::Unretained(this)));
 
   message_loop_.Run();
 
   filter = fake_bluetooth_adapter_client_->GetDiscoveryFilter();
   EXPECT_EQ("le", *filter->transport);
   EXPECT_EQ(-60, *filter->rssi);
   EXPECT_EQ(nullptr, filter->pathloss.get());
   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"));
 
-  BluetoothDiscoveryFilter* df3 = new BluetoothDiscoveryFilter(
-      BluetoothDiscoveryFilter::Transport::TRANSPORT_CLASSIC);
+  BluetoothDiscoveryFilter* df3 =
+      new BluetoothDiscoveryFilter(device::BLUETOOTH_TRANSPORT_CLASSIC);
   df3->SetRSSI(-65);
   df3->AddUUID(BluetoothUUID("1020"));
   df3->AddUUID(BluetoothUUID("1003"));
   std::unique_ptr<BluetoothDiscoveryFilter> discovery_filter3(df3);
 
   adapter_->StartDiscoverySessionWithFilter(
       std::move(discovery_filter3),
       base::Bind(&BluetoothBlueZTest::DiscoverySessionCallback,
                  base::Unretained(this)),
       base::Bind(&BluetoothBlueZTest::ErrorCallback, base::Unretained(this)));
@@ skipping 2378 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