chrome.bluetoothLowEnergy: Implement writeCharacteristicValue.

chrome/browser/extensions/api/bluetooth_low_energy/bluetooth_low_energy_apitest.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 "base/memory/scoped_ptr.h"
 #include "chrome/browser/extensions/api/bluetooth_low_energy/bluetooth_low_energy_api.h"
 #include "chrome/browser/extensions/api/bluetooth_low_energy/bluetooth_low_energy_event_router.h"
 #include "chrome/browser/extensions/extension_apitest.h"
 #include "chrome/browser/extensions/extension_function_test_utils.h"
 #include "chrome/browser/extensions/extension_test_message_listener.h"
 #include "device/bluetooth/test/mock_bluetooth_adapter.h"
 #include "device/bluetooth/test/mock_bluetooth_device.h"
 #include "device/bluetooth/test/mock_bluetooth_gatt_characteristic.h"
 #include "device/bluetooth/test/mock_bluetooth_gatt_service.h"
 #include "testing/gmock/include/gmock/gmock.h"
 
 using device::BluetoothUUID;
 using device::BluetoothAdapter;
 using device::BluetoothDevice;
 using device::BluetoothGattCharacteristic;
 using device::BluetoothGattService;
 using device::MockBluetoothAdapter;
 using device::MockBluetoothDevice;
 using device::MockBluetoothGattCharacteristic;
 using device::MockBluetoothGattService;
 using testing::Return;
+using testing::ReturnRef;
 using testing::ReturnRefOfCopy;
+using testing::SaveArg;
 using testing::_;
 
 namespace utils = extension_function_test_utils;
 
 namespace {
 
 const char kTestLeDeviceAddress[] = "11:22:33:44:55:66";
 const char kTestLeDeviceName[] = "Test LE Device";
 
 const char kTestServiceId0[] = "service_id0";
@@ skipping 118 matching lines @@
   scoped_ptr<testing::NiceMock<MockBluetoothGattService> > service0_;
   scoped_ptr<testing::NiceMock<MockBluetoothGattService> > service1_;
   scoped_ptr<testing::NiceMock<MockBluetoothGattCharacteristic> > chrc0_;
   scoped_ptr<testing::NiceMock<MockBluetoothGattCharacteristic> > chrc1_;
   scoped_ptr<testing::NiceMock<MockBluetoothGattCharacteristic> > chrc2_;
 
  private:
   scoped_refptr<extensions::Extension> empty_extension_;
 };
 
+void WriteValueSuccessCallback(const std::vector<uint8>& value,
+                               const base::Closure& callback,
+                               const base::Closure& error_callback) {
+  callback.Run();
+}
+
+void WriteValueErrorCallback(const std::vector<uint8>& value,
+                             const base::Closure& callback,
+                             const base::Closure& error_callback) {
+  error_callback.Run();
+}
+
 IN_PROC_BROWSER_TEST_F(BluetoothLowEnergyApiTest, GetServices) {
   ResultCatcher catcher;
   catcher.RestrictToProfile(browser()->profile());
 
   std::vector<BluetoothGattService*> services;
   services.push_back(service0_.get());
   services.push_back(service1_.get());
 
   EXPECT_CALL(*mock_adapter_, GetDevice(_))
       .Times(3)
@@ skipping 282 matching lines @@
 
   listener.Reply("go");
 
   EXPECT_TRUE(catcher.GetNextResult()) << catcher.message();
 
   event_router()->GattCharacteristicRemoved(service0_.get(), chrc0_.get());
   event_router()->GattServiceRemoved(device_.get(), service0_.get());
   event_router()->DeviceRemoved(mock_adapter_, device_.get());
 }
 
+IN_PROC_BROWSER_TEST_F(BluetoothLowEnergyApiTest, WriteCharacteristicValue) {
+  ResultCatcher catcher;
+  catcher.RestrictToProfile(browser()->profile());
+
+  event_router()->DeviceAdded(mock_adapter_, device_.get());
+  event_router()->GattServiceAdded(device_.get(), service0_.get());
+  event_router()->GattCharacteristicAdded(service0_.get(), chrc0_.get());
+
+  EXPECT_CALL(*mock_adapter_, GetDevice(_)).Times(3).WillRepeatedly(

[keybuk, 2014/05/06 16:44:19]

nit: break across multiple lines

[armansito, 2014/05/06 19:26:36]

Done.

+      Return(device_.get()));
+
+  EXPECT_CALL(*device_, GetGattService(kTestServiceId0))
+      .Times(3)
+      .WillRepeatedly(Return(service0_.get()));
+
+  EXPECT_CALL(*service0_, GetCharacteristic(kTestCharacteristicId0))
+      .Times(3)
+      .WillRepeatedly(Return(chrc0_.get()));
+
+  std::vector<uint8> write_value;
+  EXPECT_CALL(*chrc0_, WriteRemoteCharacteristic(_, _, _))
+      .Times(2)
+      .WillOnce(Invoke(&WriteValueErrorCallback))
+      .WillOnce(
+          DoAll(SaveArg<0>(&write_value), Invoke(&WriteValueSuccessCallback)));
+  EXPECT_CALL(*chrc0_, GetValue()).Times(1).WillOnce(ReturnRef(write_value));
+
+  ExtensionTestMessageListener listener("ready", true);
+  ASSERT_TRUE(LoadExtension(test_data_dir_.AppendASCII(
+      "bluetooth_low_energy/write_characteristic_value")));
+  EXPECT_TRUE(listener.WaitUntilSatisfied());
+
+  listener.Reply("go");
+
+  EXPECT_TRUE(catcher.GetNextResult()) << catcher.message();
+
+  event_router()->GattCharacteristicRemoved(service0_.get(), chrc0_.get());
+  event_router()->GattServiceRemoved(device_.get(), service0_.get());
+  event_router()->DeviceRemoved(mock_adapter_, device_.get());
+}
+
 }  // namespace