device/bluetooth: split out transport enum

device/bluetooth/bluetooth_adapter_unittest.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 "device/bluetooth/bluetooth_adapter.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <memory>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/memory/ref_counted.h"
 #include "base/run_loop.h"
 #include "build/build_config.h"
 #include "device/bluetooth/bluetooth_device.h"
 #include "device/bluetooth/bluetooth_discovery_session.h"
 #include "device/bluetooth/bluetooth_gatt_service.h"
 #include "device/bluetooth/bluetooth_local_gatt_characteristic.h"
 #include "device/bluetooth/bluetooth_local_gatt_descriptor.h"
 #include "device/bluetooth/bluetooth_local_gatt_service.h"
+#include "device/bluetooth/bluetooth_types.h"
 #include "device/bluetooth/test/bluetooth_test.h"
 #include "device/bluetooth/test/test_bluetooth_adapter_observer.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 #if defined(OS_ANDROID)
 #include "device/bluetooth/test/bluetooth_test_android.h"
 #elif defined(OS_MACOSX)
 #include "device/bluetooth/test/bluetooth_test_mac.h"
 #elif defined(OS_WIN)
 #include "device/bluetooth/test/bluetooth_test_win.h"
@@ skipping 226 matching lines @@
 
   adapter->CleanupSessions();
 }
 
 TEST(BluetoothAdapterTest, GetMergedDiscoveryFilterRssi) {
   scoped_refptr<TestBluetoothAdapter> adapter = new TestBluetoothAdapter();
   int16_t resulting_rssi;
   uint16_t resulting_pathloss;
   std::unique_ptr<BluetoothDiscoveryFilter> resulting_filter;
 
-  BluetoothDiscoveryFilter* df = new BluetoothDiscoveryFilter(
-      BluetoothDiscoveryFilter::Transport::TRANSPORT_LE);
+  BluetoothDiscoveryFilter* df =
+      new BluetoothDiscoveryFilter(BluetoothTransport::TRANSPORT_LE);
   df->SetRSSI(-30);
   std::unique_ptr<BluetoothDiscoveryFilter> discovery_filter(df);
 
-  BluetoothDiscoveryFilter* df2 = new BluetoothDiscoveryFilter(
-      BluetoothDiscoveryFilter::Transport::TRANSPORT_LE);
+  BluetoothDiscoveryFilter* df2 =
+      new BluetoothDiscoveryFilter(BluetoothTransport::TRANSPORT_LE);
   df2->SetRSSI(-65);
   std::unique_ptr<BluetoothDiscoveryFilter> discovery_filter2(df2);
 
   // make sure adapter have one session wihout filtering.
   adapter->InjectFilteredSession(std::move(discovery_filter));
 
   // DO_NOTHING should have no impact
   resulting_filter = adapter->GetMergedDiscoveryFilter();
   resulting_filter->GetRSSI(&resulting_rssi);
   EXPECT_EQ(-30, resulting_rssi);
@@ skipping 13 matching lines @@
   // ommit bigger value, result should stay same
   resulting_filter = adapter->GetMergedDiscoveryFilterMasked(df);
   resulting_filter->GetRSSI(&resulting_rssi);
   EXPECT_EQ(-65, resulting_rssi);
 
   // ommit lower value, result should change
   resulting_filter = adapter->GetMergedDiscoveryFilterMasked(df2);
   resulting_filter->GetRSSI(&resulting_rssi);
   EXPECT_EQ(-30, resulting_rssi);
 
-  BluetoothDiscoveryFilter* df3 = new BluetoothDiscoveryFilter(
-      BluetoothDiscoveryFilter::Transport::TRANSPORT_LE);
+  BluetoothDiscoveryFilter* df3 =
+      new BluetoothDiscoveryFilter(BluetoothTransport::TRANSPORT_LE);
   df3->SetPathloss(60);
   std::unique_ptr<BluetoothDiscoveryFilter> discovery_filter3(df3);
 
   // when rssi and pathloss are merged, both should be cleared, becuase there is
   // no way to tell which filter will be more generic
   adapter->InjectFilteredSession(std::move(discovery_filter3));
   resulting_filter = adapter->GetMergedDiscoveryFilter();
   EXPECT_FALSE(resulting_filter->GetRSSI(&resulting_rssi));
   EXPECT_FALSE(resulting_filter->GetPathloss(&resulting_pathloss));
 
   adapter->CleanupSessions();
 }
 
 TEST(BluetoothAdapterTest, GetMergedDiscoveryFilterTransport) {
   scoped_refptr<TestBluetoothAdapter> adapter = new TestBluetoothAdapter();
   std::unique_ptr<BluetoothDiscoveryFilter> resulting_filter;
 
-  BluetoothDiscoveryFilter* df = new BluetoothDiscoveryFilter(
-      BluetoothDiscoveryFilter::Transport::TRANSPORT_CLASSIC);
+  BluetoothDiscoveryFilter* df =
+      new BluetoothDiscoveryFilter(BluetoothTransport::TRANSPORT_CLASSIC);
   std::unique_ptr<BluetoothDiscoveryFilter> discovery_filter(df);
 
-  BluetoothDiscoveryFilter* df2 = new BluetoothDiscoveryFilter(
-      BluetoothDiscoveryFilter::Transport::TRANSPORT_LE);
+  BluetoothDiscoveryFilter* df2 =
+      new BluetoothDiscoveryFilter(BluetoothTransport::TRANSPORT_LE);
   std::unique_ptr<BluetoothDiscoveryFilter> discovery_filter2(df2);
 
   adapter->InjectFilteredSession(std::move(discovery_filter));
 
   // Just one filter, make sure transport was properly rewritten
   resulting_filter = adapter->GetMergedDiscoveryFilter();
-  EXPECT_EQ(BluetoothDiscoveryFilter::Transport::TRANSPORT_CLASSIC,
+  EXPECT_EQ(BluetoothTransport::TRANSPORT_CLASSIC,
             resulting_filter->GetTransport());
 
   adapter->InjectFilteredSession(std::move(discovery_filter2));
 
   // Two filters, should have OR of both transport's
   resulting_filter = adapter->GetMergedDiscoveryFilter();
-  EXPECT_EQ(BluetoothDiscoveryFilter::Transport::TRANSPORT_DUAL,
+  EXPECT_EQ(BluetoothTransport::TRANSPORT_DUAL,
             resulting_filter->GetTransport());
 
   // When 1st filter is masked, 2nd filter transport should be returned.
   resulting_filter = adapter->GetMergedDiscoveryFilterMasked(df);
-  EXPECT_EQ(BluetoothDiscoveryFilter::Transport::TRANSPORT_LE,
-            resulting_filter->GetTransport());
+  EXPECT_EQ(BluetoothTransport::TRANSPORT_LE, resulting_filter->GetTransport());
 
   // When 2nd filter is masked, 1st filter transport should be returned.
   resulting_filter = adapter->GetMergedDiscoveryFilterMasked(df2);
-  EXPECT_EQ(BluetoothDiscoveryFilter::Transport::TRANSPORT_CLASSIC,
+  EXPECT_EQ(BluetoothTransport::TRANSPORT_CLASSIC,
             resulting_filter->GetTransport());
 
-  BluetoothDiscoveryFilter* df3 = new BluetoothDiscoveryFilter(
-      BluetoothDiscoveryFilter::Transport::TRANSPORT_LE);
-  df3->CopyFrom(BluetoothDiscoveryFilter(
-      BluetoothDiscoveryFilter::Transport::TRANSPORT_DUAL));
+  BluetoothDiscoveryFilter* df3 =
+      new BluetoothDiscoveryFilter(BluetoothTransport::TRANSPORT_LE);
+  df3->CopyFrom(BluetoothDiscoveryFilter(BluetoothTransport::TRANSPORT_DUAL));
   std::unique_ptr<BluetoothDiscoveryFilter> discovery_filter3(df3);
 
   // Merging empty filter in should result in empty filter
   adapter->InjectFilteredSession(std::move(discovery_filter3));
   resulting_filter = adapter->GetMergedDiscoveryFilter();
   EXPECT_TRUE(resulting_filter->IsDefault());
 
   adapter->CleanupSessions();
 }
 
 TEST(BluetoothAdapterTest, GetMergedDiscoveryFilterAllFields) {
   scoped_refptr<TestBluetoothAdapter> adapter = new TestBluetoothAdapter();
   int16_t resulting_rssi;
   std::set<device::BluetoothUUID> resulting_uuids;
 
-  BluetoothDiscoveryFilter* df = new BluetoothDiscoveryFilter(
-      BluetoothDiscoveryFilter::Transport::TRANSPORT_LE);
+  BluetoothDiscoveryFilter* df =
+      new BluetoothDiscoveryFilter(BluetoothTransport::TRANSPORT_LE);
   df->SetRSSI(-60);
   df->AddUUID(device::BluetoothUUID("1000"));
   std::unique_ptr<BluetoothDiscoveryFilter> discovery_filter(df);
 
-  BluetoothDiscoveryFilter* df2 = new BluetoothDiscoveryFilter(
-      BluetoothDiscoveryFilter::Transport::TRANSPORT_LE);
+  BluetoothDiscoveryFilter* df2 =
+      new BluetoothDiscoveryFilter(BluetoothTransport::TRANSPORT_LE);
   df2->SetRSSI(-85);
-  df2->SetTransport(BluetoothDiscoveryFilter::Transport::TRANSPORT_LE);
+  df2->SetTransport(BluetoothTransport::TRANSPORT_LE);
   df2->AddUUID(device::BluetoothUUID("1020"));
   df2->AddUUID(device::BluetoothUUID("1001"));
   std::unique_ptr<BluetoothDiscoveryFilter> discovery_filter2(df2);
 
-  BluetoothDiscoveryFilter* df3 = new BluetoothDiscoveryFilter(
-      BluetoothDiscoveryFilter::Transport::TRANSPORT_LE);
+  BluetoothDiscoveryFilter* df3 =
+      new BluetoothDiscoveryFilter(BluetoothTransport::TRANSPORT_LE);
   df3->SetRSSI(-65);
-  df3->SetTransport(BluetoothDiscoveryFilter::Transport::TRANSPORT_CLASSIC);
+  df3->SetTransport(BluetoothTransport::TRANSPORT_CLASSIC);
   df3->AddUUID(device::BluetoothUUID("1020"));
   df3->AddUUID(device::BluetoothUUID("1003"));
   std::unique_ptr<BluetoothDiscoveryFilter> discovery_filter3(df3);
 
   // make sure adapter have one session wihout filtering.
   adapter->InjectFilteredSession(std::move(discovery_filter));
   adapter->InjectFilteredSession(std::move(discovery_filter2));
   adapter->InjectFilteredSession(std::move(discovery_filter3));
 
   std::unique_ptr<BluetoothDiscoveryFilter> resulting_filter =
       adapter->GetMergedDiscoveryFilter();
   resulting_filter->GetRSSI(&resulting_rssi);
   resulting_filter->GetUUIDs(resulting_uuids);
   EXPECT_TRUE(resulting_filter->GetTransport());
-  EXPECT_EQ(BluetoothDiscoveryFilter::Transport::TRANSPORT_DUAL,
+  EXPECT_EQ(BluetoothTransport::TRANSPORT_DUAL,
             resulting_filter->GetTransport());
   EXPECT_EQ(-85, resulting_rssi);
   EXPECT_EQ(4UL, resulting_uuids.size());
   EXPECT_TRUE(resulting_uuids.find(device::BluetoothUUID("1000")) !=
               resulting_uuids.end());
   EXPECT_TRUE(resulting_uuids.find(device::BluetoothUUID("1001")) !=
               resulting_uuids.end());
   EXPECT_TRUE(resulting_uuids.find(device::BluetoothUUID("1003")) !=
               resulting_uuids.end());
   EXPECT_TRUE(resulting_uuids.find(device::BluetoothUUID("1020")) !=
               resulting_uuids.end());
 
   resulting_filter = adapter->GetMergedDiscoveryFilterMasked(df);
-  EXPECT_EQ(BluetoothDiscoveryFilter::Transport::TRANSPORT_DUAL,
+  EXPECT_EQ(BluetoothTransport::TRANSPORT_DUAL,
             resulting_filter->GetTransport());
 
   adapter->CleanupSessions();
 }
 
 // TODO(scheib): Enable BluetoothTest fixture tests on all platforms.
 #if defined(OS_ANDROID) || defined(OS_MACOSX) || defined(OS_WIN)
 TEST_F(BluetoothTest, ConstructDefaultAdapter) {
   InitWithDefaultAdapter();
   if (!adapter_->IsPresent()) {
@@ skipping 327 matching lines @@
   service->Register(GetCallback(Call::NOT_EXPECTED),
                     GetGattErrorCallback(Call::EXPECTED));
   service->Unregister(GetCallback(Call::EXPECTED),
                       GetGattErrorCallback(Call::NOT_EXPECTED));
   service->Unregister(GetCallback(Call::NOT_EXPECTED),
                       GetGattErrorCallback(Call::EXPECTED));
 }
 #endif  // defined(OS_CHROMEOS) || defined(OS_LINUX)
 
 }  // namespace device