Bluetooth: Add support for pairing display notifications

device/bluetooth/bluetooth_experimental_chromeos_unittest.cc

 // Copyright (c) 2013 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/command_line.h"
 #include "base/message_loop.h"
 #include "base/utf_string_conversions.h"
 #include "chromeos/chromeos_switches.h"
 #include "chromeos/dbus/fake_bluetooth_adapter_client.h"
 #include "chromeos/dbus/fake_bluetooth_device_client.h"
@@ skipping 110 matching lines @@
 };
 
 class TestPairingDelegate : public BluetoothDevice::PairingDelegate {
  public:
   TestPairingDelegate()
       : call_count_(0),
         request_pincode_count_(0),
         request_passkey_count_(0),
         display_pincode_count_(0),
         display_passkey_count_(0),
+        keys_entered_count_(0),
         confirm_passkey_count_(0),
         dismiss_count_(0) {}
   virtual ~TestPairingDelegate() {}
 
   void RequestPinCode(BluetoothDevice* device) OVERRIDE {
     ++call_count_;
     ++request_pincode_count_;
     QuitMessageLoop();
   }
 
@@ skipping 12 matching lines @@
   }
 
   void DisplayPasskey(BluetoothDevice* device,
                       uint32 passkey) OVERRIDE {
     ++call_count_;
     ++display_passkey_count_;
     last_passkey_ = passkey;
     QuitMessageLoop();
   }
 
+  void KeysEntered(BluetoothDevice* device,
+                   uint32 entered) OVERRIDE {
+    ++call_count_;
+    ++keys_entered_count_;
+    last_entered_ = entered;
+    QuitMessageLoop();
+  }
+
   void ConfirmPasskey(BluetoothDevice* device,
                       uint32 passkey) OVERRIDE {
     ++call_count_;
     ++confirm_passkey_count_;
     last_passkey_ = passkey;
     QuitMessageLoop();
   }
 
   void DismissDisplayOrConfirm() OVERRIDE {
     ++call_count_;
     ++dismiss_count_;
     QuitMessageLoop();
   }
 
   int call_count_;
   int request_pincode_count_;
   int request_passkey_count_;
   int display_pincode_count_;
   int display_passkey_count_;
+  int keys_entered_count_;
   int confirm_passkey_count_;
   int dismiss_count_;
   uint32 last_passkey_;
+  uint32 last_entered_;
   std::string last_pincode_;
 
   private:
    // Some tests use a message loop since background processing is simulated;
    // break out of those loops.
    void QuitMessageLoop() {
      if (MessageLoop::current() && MessageLoop::current()->is_running())
        MessageLoop::current()->Quit();
    }
 };
@@ skipping 1016 matching lines @@
   adapter_->AddObserver(&observer);
 
   TestPairingDelegate pairing_delegate;
   device->Connect(
       &pairing_delegate,
       base::Bind(&BluetoothExperimentalChromeOSTest::Callback,
                  base::Unretained(this)),
       base::Bind(&BluetoothExperimentalChromeOSTest::ConnectErrorCallback,
                  base::Unretained(this)));
 
-  EXPECT_EQ(1, pairing_delegate.call_count_);
+  // One call for DisplayPasskey() and one for KeysEntered().
+  EXPECT_EQ(2, pairing_delegate.call_count_);
   EXPECT_EQ(1, pairing_delegate.display_passkey_count_);
   EXPECT_EQ(123456U, pairing_delegate.last_passkey_);
   EXPECT_TRUE(device->IsConnecting());
 

[keybuk, 2013/04/18 23:50:36]

Doesn't check the KeysEntered call here.

Should verify that last_entered is 0 and keys_entered_count is 1

[deymo, 2013/04/19 01:35:00]

Done.

-  // TODO(keybuk): verify we get typing notifications
+  // One call to KeysEntered() for each key, including [enter].
+  for(int i = 1; i <= 7; ++i) {
+    message_loop.Run();
+
+    EXPECT_EQ(2 + i, pairing_delegate.call_count_);
+    EXPECT_EQ(1 + i, pairing_delegate.keys_entered_count_);
+    EXPECT_EQ((uint32_t)i, pairing_delegate.last_entered_);

[keybuk, 2013/04/18 23:50:36]

style: use static_cast<>
http://google-styleguide.googlecode.com/svn/trunk/cppguide.xml#Casting

(probably much cleaner to make "i" uint32_t)

[deymo, 2013/04/19 01:35:00]

Done.

+  }
 
   message_loop.Run();
 
+  // 8 KeysEntered notifications (0 to 7, inclusive). Two aditional calls for
+  // DisplayPasskey() and DismissDisplayOrConfirm().
+  EXPECT_EQ(10, pairing_delegate.call_count_);
+  EXPECT_EQ(8, pairing_delegate.keys_entered_count_);
+  EXPECT_EQ(7U, pairing_delegate.last_entered_);
+
   EXPECT_EQ(1, callback_count_);
   EXPECT_EQ(0, error_callback_count_);
 
   // One change for connected, and one for paired.
   EXPECT_EQ(2, observer.device_changed_count_);
   EXPECT_EQ(device, observer.last_device_);
 
   EXPECT_TRUE(device->IsConnected());
   EXPECT_FALSE(device->IsConnecting());
 
   EXPECT_TRUE(device->IsPaired());
 
   // Pairing dialog should be dismissed
-  EXPECT_EQ(2, pairing_delegate.call_count_);
   EXPECT_EQ(1, pairing_delegate.dismiss_count_);
 
   // Make sure the trusted property has been set to true.
   FakeBluetoothDeviceClient::Properties* properties =
       fake_bluetooth_device_client_->GetProperties(
           dbus::ObjectPath(FakeBluetoothDeviceClient::kMotorolaKeyboardPath));
   EXPECT_TRUE(properties->trusted.value());
 }
 
 TEST_F(BluetoothExperimentalChromeOSTest, PairSonyHeadphones) {
@@ skipping 585 matching lines @@
   EXPECT_FALSE(device->IsConnected());
   EXPECT_FALSE(device->IsConnecting());
   EXPECT_FALSE(device->IsPaired());
 
   // Pairing dialog should be dismissed
   EXPECT_EQ(1, pairing_delegate.call_count_);
   EXPECT_EQ(1, pairing_delegate.dismiss_count_);
 }
 
 }  // namespace chromeos