Add bluetooth.getName API.

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"
 #include "chrome/browser/extensions/api/bluetooth/bluetooth_api.h"
 #include "chrome/browser/extensions/extension_apitest.h"
 #include "chrome/browser/extensions/extension_function_test_utils.h"
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/extensions/extension_test_message_listener.h"
 #include "chrome/browser/ui/browser.h"
 #include "chromeos/dbus/bluetooth_out_of_band_client.h"
 #include "chrome/test/base/ui_test_utils.h"
 #include "testing/gmock/include/gmock/gmock.h"
 
 using extensions::Extension;
 
 namespace utils = extension_function_test_utils;
 namespace api = extensions::api;
 
 namespace {
 
+static const char* kAddress = "01:02:03:04:05:06";
+static const char* kName = "whatsinaname";
+
 class BluetoothApiTest : public PlatformAppApiTest {
  public:
   BluetoothApiTest() : empty_extension_(utils::CreateEmptyExtension()) {}
 
   virtual void SetUpOnMainThread() OVERRIDE {
     // The browser will clean this up when it is torn down
     mock_adapter_ = new testing::StrictMock<chromeos::MockBluetoothAdapter>;
     event_router()->SetAdapterForTest(mock_adapter_);
 
     device1_.reset(new testing::NiceMock<chromeos::MockBluetoothDevice>(
         mock_adapter_, "d1", "11:12:13:14:15:16",
         true /* paired */, false /* bonded */, true /* connected */));
     device2_.reset(new testing::NiceMock<chromeos::MockBluetoothDevice>(
         mock_adapter_, "d2", "21:22:23:24:25:26",
         false /* paired */, true /* bonded */, false /* connected */));
   }
 
   void expectBooleanResult(bool expected,
-                           UIThreadExtensionFunction* function,
-                           const std::string& args) {
+                           UIThreadExtensionFunction* function) {
     scoped_ptr<base::Value> result(
-        utils::RunFunctionAndReturnSingleResult(function, args, browser()));
+        utils::RunFunctionAndReturnSingleResult(function, "[]", browser()));
     ASSERT_TRUE(result.get() != NULL);
     ASSERT_EQ(base::Value::TYPE_BOOLEAN, result->GetType());
     bool boolean_value;
     result->GetAsBoolean(&boolean_value);
     EXPECT_EQ(expected, boolean_value);
   }
 
+  void expectStringResult(const std::string& expected,
+                         UIThreadExtensionFunction* function) {
+    scoped_ptr<base::Value> result(
+        utils::RunFunctionAndReturnSingleResult(function, "[]", browser()));
+    ASSERT_TRUE(result.get() != NULL);
+    ASSERT_EQ(base::Value::TYPE_STRING, result->GetType());
+    std::string string_value;
+    result->GetAsString(&string_value);
+    EXPECT_EQ(expected, string_value);
+  }
+
   template <class T>
   T* setupFunction(T* function) {
     function->set_extension(empty_extension_.get());
     function->set_has_callback(true);
     return function;
   }
 
  protected:
   testing::StrictMock<chromeos::MockBluetoothAdapter>* mock_adapter_;
   scoped_ptr<testing::NiceMock<chromeos::MockBluetoothDevice> > device1_;
@@ skipping 36 matching lines @@
 
 }  // namespace
 
 IN_PROC_BROWSER_TEST_F(BluetoothApiTest, IsAvailable) {
   EXPECT_CALL(*mock_adapter_, IsPresent())
       .WillOnce(testing::Return(false));
 
   scoped_refptr<api::BluetoothIsAvailableFunction> is_available;
 
   is_available = setupFunction(new api::BluetoothIsAvailableFunction);
-  expectBooleanResult(false, is_available, "[]");
+  expectBooleanResult(false, is_available);
 
   testing::Mock::VerifyAndClearExpectations(mock_adapter_);
   EXPECT_CALL(*mock_adapter_, IsPresent())
       .WillOnce(testing::Return(true));
 
   is_available = setupFunction(new api::BluetoothIsAvailableFunction);
-  expectBooleanResult(true, is_available, "[]");
+  expectBooleanResult(true, is_available);
 }
 
 IN_PROC_BROWSER_TEST_F(BluetoothApiTest, IsPowered) {
   EXPECT_CALL(*mock_adapter_, IsPowered())
       .WillOnce(testing::Return(false));
 
   scoped_refptr<api::BluetoothIsPoweredFunction> is_powered;
 
   is_powered = setupFunction(new api::BluetoothIsPoweredFunction);
-  expectBooleanResult(false, is_powered, "[]");
+  expectBooleanResult(false, is_powered);
 
   testing::Mock::VerifyAndClearExpectations(mock_adapter_);
   EXPECT_CALL(*mock_adapter_, IsPowered())
       .WillOnce(testing::Return(true));
 
   is_powered = setupFunction(new api::BluetoothIsPoweredFunction);
-  expectBooleanResult(true, is_powered, "[]");
+  expectBooleanResult(true, is_powered);
+}
+
+IN_PROC_BROWSER_TEST_F(BluetoothApiTest, GetAddress) {
+  std::string address(kAddress);
+  EXPECT_CALL(*mock_adapter_, address()).WillOnce(testing::ReturnRef(address));
+
+  scoped_refptr<api::BluetoothGetAddressFunction> get_address;
+  get_address = setupFunction(new api::BluetoothGetAddressFunction);
+  expectStringResult(address, get_address);
+}
+
+IN_PROC_BROWSER_TEST_F(BluetoothApiTest, GetName) {
+  std::string name(kName);
+  EXPECT_CALL(*mock_adapter_, name()).WillOnce(testing::ReturnRef(name));
+
+  scoped_refptr<api::BluetoothGetNameFunction> get_name;
+  get_name = setupFunction(new api::BluetoothGetNameFunction);
+  expectStringResult(name, get_name);
 }
 
 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(kCanonicalUuid))
       .WillOnce(testing::Return(false));
   EXPECT_CALL(*device2_, ProvidesServiceWithUUID(kCanonicalUuid))
@@ skipping 262 matching lines @@
   event_router()->AdapterPoweredChanged(mock_adapter_, false);
   event_router()->AdapterPresentChanged(mock_adapter_, true);
   event_router()->AdapterPresentChanged(mock_adapter_, false);
   event_router()->AdapterDiscoveringChanged(mock_adapter_, true);
   event_router()->AdapterDiscoveringChanged(mock_adapter_, false);
 
   listener.Reply("go");
 
   EXPECT_TRUE(catcher.GetNextResult()) << catcher.message();
 }