Ensure canonical Bluetooth UUIDs are used.

chrome/browser/extensions/api/bluetooth/bluetooth_apitest_chromeos.cc

 // Copyright (c) 2012 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 <string.h>
 
 #include "chrome/browser/chromeos/bluetooth/bluetooth_adapter.h"
 #include "chrome/browser/chromeos/bluetooth/test/mock_bluetooth_adapter.h"
 #include "chrome/browser/chromeos/bluetooth/test/mock_bluetooth_device.h"
 #include "chrome/browser/chromeos/extensions/bluetooth_event_router.h"
@@ skipping 57 matching lines @@
 
   chromeos::ExtensionBluetoothEventRouter* event_router() {
     return browser()->profile()->GetExtensionService()->
         bluetooth_event_router();
   }
 
  private:
   scoped_refptr<Extension> empty_extension_;
 };
 
+// This is the canonical UUID for the short UUID 0010.
+static const char kCanonicalUuid[] = "00000010-0000-1000-8000-00805f9b34fb";
 static const char kOutOfBandPairingDataHash[] = "0123456789ABCDEh";
 static const char kOutOfBandPairingDataRandomizer[] = "0123456789ABCDEr";
 
 static chromeos::BluetoothOutOfBandPairingData GetOutOfBandPairingData() {
   chromeos::BluetoothOutOfBandPairingData data;
   memcpy(&(data.hash), kOutOfBandPairingDataHash,
       chromeos::kBluetoothOutOfBandPairingDataSize);
   memcpy(&(data.randomizer), kOutOfBandPairingDataRandomizer,
       chromeos::kBluetoothOutOfBandPairingDataSize);
   return data;
@@ skipping 45 matching lines @@
 
   is_powered = setupFunction(new api::BluetoothIsPoweredFunction);
   expectBooleanResult(true, is_powered, "[]");
 }
 
 IN_PROC_BROWSER_TEST_F(BluetoothApiTest, GetDevices) {
   chromeos::BluetoothAdapter::ConstDeviceList devices;
   devices.push_back(device1_.get());
   devices.push_back(device2_.get());
 
-  EXPECT_CALL(*device1_, ProvidesServiceWithUUID("foo"))
+  EXPECT_CALL(*device1_, ProvidesServiceWithUUID(kCanonicalUuid))
       .WillOnce(testing::Return(false));
-  EXPECT_CALL(*device2_, ProvidesServiceWithUUID("foo"))
+  EXPECT_CALL(*device2_, ProvidesServiceWithUUID(kCanonicalUuid))
       .WillOnce(testing::Return(true));
 
   EXPECT_CALL(*mock_adapter_, GetDevices())
       .WillOnce(testing::Return(devices));
 
   scoped_refptr<api::BluetoothGetDevicesFunction> get_devices;
 
   get_devices = setupFunction(new api::BluetoothGetDevicesFunction);
   scoped_ptr<base::Value> result(utils::RunFunctionAndReturnSingleResult(
         get_devices,
-        "[{\"uuid\":\"foo\"}]",
+        "[{\"uuid\":\"0010\"}]",
         browser()));
 
   ASSERT_EQ(base::Value::TYPE_LIST, result->GetType());
   base::ListValue* list;
   ASSERT_TRUE(result->GetAsList(&list));
 
   EXPECT_EQ(1u, list->GetSize());
   base::Value* device_value;
   EXPECT_TRUE(list->Get(0, &device_value));
   EXPECT_EQ(base::Value::TYPE_DICTIONARY, device_value->GetType());
@@ skipping 22 matching lines @@
       .WillOnce(testing::Return(devices));
 
   get_devices = setupFunction(new api::BluetoothGetDevicesFunction);
   result.reset(
       utils::RunFunctionAndReturnSingleResult(get_devices, "[{}]", browser()));
 
   ASSERT_EQ(base::Value::TYPE_LIST, result->GetType());
   ASSERT_TRUE(result->GetAsList(&list));
 
   EXPECT_EQ(2u, list->GetSize());
+
+  // Try again with an error
+  testing::Mock::VerifyAndClearExpectations(mock_adapter_);
+
+  get_devices = setupFunction(new api::BluetoothGetDevicesFunction);
+  std::string error(
+      utils::RunFunctionAndReturnError(get_devices,
+                                       "[{\"uuid\":\"foo\"}]",
+                                       browser()));
+  EXPECT_FALSE(error.empty());

[satorux1, 2012/07/24 18:29:21]

would it make sense to check the error contents with EXPECT_EQ()?

[bryeung, 2012/07/24 19:50:09]

Doesn't really seem worthwhile: I don't think it adds that much safety but it
requires moving the error constants to a worse position.

 }
 
 IN_PROC_BROWSER_TEST_F(BluetoothApiTest, GetLocalOutOfBandPairingData) {
   EXPECT_CALL(*mock_adapter_,
               ReadLocalOutOfBandPairingData(
                   testing::Truly(CallOutOfBandPairingDataCallback),
                   testing::_));
 
   scoped_refptr<api::BluetoothGetLocalOutOfBandPairingDataFunction>
       get_oob_function(setupFunction(
@@ skipping 153 matching lines @@
 
   event_router()->AdapterPoweredChanged(mock_adapter_, true);
   event_router()->AdapterPoweredChanged(mock_adapter_, false);
   event_router()->AdapterPresentChanged(mock_adapter_, true);
   event_router()->AdapterPresentChanged(mock_adapter_, false);
 
   listener.Reply("go");
 
   EXPECT_TRUE(catcher.GetNextResult()) << catcher.message();
 }