DO NOT SUBMIT bluetooth-fuzzer: Draft fuzzer

content/shell/browser/layout_test/layout_test_bluetooth_adapter_provider.cc

 // Copyright 2015 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 "content/shell/browser/layout_test/layout_test_bluetooth_adapter_provider.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
@@ skipping 483 matching lines @@
   adapter->AddMockDevice(std::move(device));
 
   return adapter;
 }
 
 // static
 scoped_refptr<NiceMockBluetoothAdapter>
 LayoutTestBluetoothAdapterProvider::GetDisconnectingHeartRateAdapter() {
   scoped_refptr<NiceMockBluetoothAdapter> adapter(GetEmptyAdapter());
   NiceMockBluetoothAdapter* adapter_ptr = adapter.get();
+
+  BluetoothDevice::UUIDList uuids;
+  uuids.push_back(BluetoothUUID(kGenericAccessServiceUUID));
+  uuids.push_back(BluetoothUUID(kHeartRateServiceUUID));
+  uuids.push_back(BluetoothUUID(kRequestDisconnectionServiceUUID));
+
   std::unique_ptr<NiceMockBluetoothDevice> device(
-      GetHeartRateDevice(adapter.get()));
+      GetConnectableDevice(adapter.get(), "Disconnecting Device", uuids));
+
   NiceMockBluetoothDevice* device_ptr = device.get();
 
   // TODO(ortuno): Implement the rest of the service's characteristics
   // See: http://crbug.com/529975
 
   device->AddMockService(GetGenericAccessService(device.get()));
   device->AddMockService(GetHeartRateService(adapter.get(), device.get()));
 
   // Set up a service and a characteristic to disconnect the device when it's
   // written to.
@@ skipping 346 matching lines @@
             BluetoothRemoteGattCharacteristic::PROPERTY_READ |
                 BluetoothRemoteGattCharacteristic::PROPERTY_WRITE));
 
     // Read response.
     std::vector<uint8_t> value(1);
     value[0] = false;
 
     ON_CALL(*peripheral_privacy_flag, ReadRemoteCharacteristic(_, _))
         .WillByDefault(RunCallback<0>(value));
 
-    // Crash if WriteRemoteCharacteristic called. Not using GoogleMock's Expect
-    // because this is used in layout tests that may not report a mock
-    // expectation error correctly as a layout test failure.
-    ON_CALL(*peripheral_privacy_flag, WriteRemoteCharacteristic(_, _, _))
-        .WillByDefault(
-            Invoke([](const std::vector<uint8_t>&, const base::Closure&,
-                      const BluetoothRemoteGattCharacteristic::ErrorCallback&) {
-              NOTREACHED();
-            }));
-
     generic_access->AddMockCharacteristic(std::move(peripheral_privacy_flag));
   }
 
   return generic_access;
 }
 
 // static
 std::unique_ptr<NiceMockBluetoothGattService>
 LayoutTestBluetoothAdapterProvider::GetHeartRateService(
     MockBluetoothAdapter* adapter,
@@ skipping 77 matching lines @@
 
 // Characteristics
 
 // static
 std::unique_ptr<NiceMockBluetoothGattCharacteristic>
 LayoutTestBluetoothAdapterProvider::GetBaseGATTCharacteristic(
     const std::string& identifier,
     MockBluetoothGattService* service,
     const std::string& uuid,
     BluetoothRemoteGattCharacteristic::Properties properties) {
-  return base::WrapUnique(new NiceMockBluetoothGattCharacteristic(
-      service, identifier, BluetoothUUID(uuid), false /* is_local */,
-      properties, NULL /* permissions */));
+  std::unique_ptr<NiceMockBluetoothGattCharacteristic> characteristic(
+      new NiceMockBluetoothGattCharacteristic(
+          service, identifier, BluetoothUUID(uuid), false /* is_local */,
+          properties, NULL /* permissions */));
+
+  device::BluetoothGattService::GattErrorCode default_error =
+      device::BluetoothGattService::GATT_ERROR_NOT_SUPPORTED;
+
+  // Default Write response.
+  ON_CALL(*characteristic, WriteRemoteCharacteristic(_, _, _))
+      .WillByDefault(RunCallback<2>(default_error));
+
+  // Read response.
+  ON_CALL(*characteristic, ReadRemoteCharacteristic(_, _))
+      .WillByDefault(RunCallback<1>(default_error));
+
+  ON_CALL(*characteristic, StartNotifySession(_, _))
+      .WillByDefault(RunCallback<1>(default_error));
+
+  return characteristic;
 }
 
 // static
 std::unique_ptr<NiceMockBluetoothGattCharacteristic>
 LayoutTestBluetoothAdapterProvider::GetErrorCharacteristic(
     MockBluetoothGattService* service,
     BluetoothRemoteGattService::GattErrorCode error_code) {
   uint32_t error_alias = error_code + 0xA1;  // Error UUIDs start at 0xA1.
   std::unique_ptr<NiceMockBluetoothGattCharacteristic> characteristic(
       GetBaseGATTCharacteristic(
@@ skipping 90 matching lines @@
   return BluetoothUUID();
 }
 
 // static
 std::string LayoutTestBluetoothAdapterProvider::makeMACAddress(uint64_t addr) {
   return BluetoothDevice::CanonicalizeAddress(
       base::StringPrintf("%012" PRIx64, addr));
 }
 
 }  // namespace content