Add an extensions keep-alive client.

extensions/renderer/api/serial/serial_api_unittest.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 "device/serial/serial_device_enumerator.h"
 #include "device/serial/serial_service_impl.h"
 #include "device/serial/test_serial_io_handler.h"
 #include "extensions/renderer/api_test_base.h"
 #include "grit/extensions_renderer_resources.h"
 
@@ skipping 420 matching lines @@
                             scoped_ptr<device::SerialDeviceEnumerator>(
                                 new FakeSerialDeviceEnumerator)),
                         &request);
   }
 
   DISALLOW_COPY_AND_ASSIGN(SerialApiTest);
 };
 
 TEST_F(SerialApiTest, GetDevices) {
   RunTest("serial_unittest.js", "testGetDevices");
+  EXPECT_EQ(1, keep_alive_counter().keep_alives());
 }
 
 TEST_F(SerialApiTest, ConnectFail) {
   io_handler_ = new FailToConnectTestIoHandler;
   RunTest("serial_unittest.js", "testConnectFail");
+  EXPECT_EQ(1, keep_alive_counter().keep_alives());
 }
 
 TEST_F(SerialApiTest, GetInfoFailOnConnect) {
   io_handler_ = new FailToGetInfoTestIoHandler(0);
   RunTest("serial_unittest.js", "testGetInfoFailOnConnect");
+  EXPECT_EQ(1, keep_alive_counter().keep_alives());

[Ken Rockot(use gerrit already), 2014/10/24 18:29:54]

It is not immediately clear to me when looking at these tests why you would want
to make assertions about keepalive counts *everywhere*. Is this a pattern we
expect everyone to follow when writing API tests? (I think not)

Is this just temporary because serial is the only available keep-alive client
for now?

[Sam McNally, 2014/10/27 05:07:24]

It was like this because serial is the only client, but I've realized that I can
use special custom bindings in the tests to avoid needing to bolt keep-alive
client testing onto serial like this.

 }
 
 TEST_F(SerialApiTest, Connect) {
   RunTest("serial_unittest.js", "testConnect");
+  EXPECT_EQ(2, keep_alive_counter().keep_alives());
 }
 
 TEST_F(SerialApiTest, ConnectDefaultOptions) {
   RunTest("serial_unittest.js", "testConnectDefaultOptions");
+  EXPECT_EQ(2, keep_alive_counter().keep_alives());
 }
 
 TEST_F(SerialApiTest, ConnectInvalidBitrate) {
   RunTest("serial_unittest.js", "testConnectInvalidBitrate");
+  EXPECT_EQ(1, keep_alive_counter().keep_alives());
 }
 
 TEST_F(SerialApiTest, GetInfo) {
   RunTest("serial_unittest.js", "testGetInfo");
+  EXPECT_EQ(3, keep_alive_counter().keep_alives());
 }
 
 TEST_F(SerialApiTest, GetInfoAfterSerialization) {
   RunTest("serial_unittest.js", "testGetInfoAfterSerialization");
+  EXPECT_EQ(3, keep_alive_counter().keep_alives());
 }
 
 TEST_F(SerialApiTest, GetInfoFailToGetPortInfo) {
   io_handler_ = new FailToGetInfoTestIoHandler(1);
   RunTest("serial_unittest.js", "testGetInfoFailToGetPortInfo");
+  EXPECT_EQ(3, keep_alive_counter().keep_alives());
 }
 
 TEST_F(SerialApiTest, GetConnections) {
   RunTest("serial_unittest.js", "testGetConnections");
+  EXPECT_EQ(3, keep_alive_counter().keep_alives());
 }
 
 TEST_F(SerialApiTest, GetControlSignals) {
   io_handler_ = new GetControlSignalsTestIoHandler;
   RunTest("serial_unittest.js", "testGetControlSignals");
   EXPECT_EQ(16u, io_handler_->num_calls());
+  EXPECT_EQ(18, keep_alive_counter().keep_alives());
 }
 
 TEST_F(SerialApiTest, SetControlSignals) {
   io_handler_ = new SetControlSignalsTestIoHandler;
   RunTest("serial_unittest.js", "testSetControlSignals");
   EXPECT_EQ(9u, io_handler_->num_calls());
+  EXPECT_EQ(11, keep_alive_counter().keep_alives());
 }
 
 TEST_F(SerialApiTest, Update) {
   io_handler_ = new ConfigurePortTestIoHandler;
   RunTest("serial_unittest.js", "testUpdate");
   EXPECT_EQ(11u, io_handler_->num_calls());
+  EXPECT_EQ(33, keep_alive_counter().keep_alives());
 }
 
 TEST_F(SerialApiTest, UpdateAcrossSerialization) {
   io_handler_ = new ConfigurePortTestIoHandler;
   RunTest("serial_unittest.js", "testUpdateAcrossSerialization");
   EXPECT_EQ(11u, io_handler_->num_calls());
+  EXPECT_EQ(33, keep_alive_counter().keep_alives());
 }
 
 TEST_F(SerialApiTest, UpdateInvalidBitrate) {
   io_handler_ = new ConfigurePortTestIoHandler;
   RunTest("serial_unittest.js", "testUpdateInvalidBitrate");
   EXPECT_EQ(1u, io_handler_->num_calls());
+  EXPECT_EQ(3, keep_alive_counter().keep_alives());
 }
 
 TEST_F(SerialApiTest, Flush) {
   io_handler_ = new FlushTestIoHandler;
   RunTest("serial_unittest.js", "testFlush");
   EXPECT_EQ(1u, io_handler_->num_calls());
+  EXPECT_EQ(3, keep_alive_counter().keep_alives());
 }
 
 TEST_F(SerialApiTest, SetPaused) {
   RunTest("serial_unittest.js", "testSetPaused");
+  EXPECT_EQ(6, keep_alive_counter().keep_alives());
 }
 
 TEST_F(SerialApiTest, Echo) {
   RunTest("serial_unittest.js", "testEcho");
+  EXPECT_EQ(3, keep_alive_counter().keep_alives());
 }
 
 TEST_F(SerialApiTest, EchoAfterSerialization) {
   RunTest("serial_unittest.js", "testEchoAfterSerialization");
+  EXPECT_EQ(3, keep_alive_counter().keep_alives());
 }
 
 TEST_F(SerialApiTest, SendDuringExistingSend) {
   RunTest("serial_unittest.js", "testSendDuringExistingSend");
+  EXPECT_EQ(4, keep_alive_counter().keep_alives());
 }
 
 TEST_F(SerialApiTest, SendAfterSuccessfulSend) {
   RunTest("serial_unittest.js", "testSendAfterSuccessfulSend");
+  EXPECT_EQ(4, keep_alive_counter().keep_alives());
 }
 
 TEST_F(SerialApiTest, SendPartialSuccessWithError) {
   io_handler_ = new SendDataWithErrorIoHandler();
   RunTest("serial_unittest.js", "testSendPartialSuccessWithError");
+  EXPECT_EQ(4, keep_alive_counter().keep_alives());
 }
 
 TEST_F(SerialApiTest, SendTimeout) {
   io_handler_ = new BlockSendsForeverSendIoHandler();
   RunTest("serial_unittest.js", "testSendTimeout");
+  EXPECT_EQ(4, keep_alive_counter().keep_alives());
 }
 
 TEST_F(SerialApiTest, SendTimeoutAfterSerialization) {
   io_handler_ = new BlockSendsForeverSendIoHandler();
   RunTest("serial_unittest.js", "testSendTimeoutAfterSerialization");
+  EXPECT_EQ(4, keep_alive_counter().keep_alives());
 }
 
 TEST_F(SerialApiTest, DisableSendTimeout) {
   io_handler_ = new BlockSendsForeverSendIoHandler();
   RunTest("serial_unittest.js", "testDisableSendTimeout");
+  EXPECT_EQ(4, keep_alive_counter().keep_alives());
 }
 
 TEST_F(SerialApiTest, PausedReceive) {
   io_handler_ = new FixedDataReceiveTestIoHandler("data");
   RunTest("serial_unittest.js", "testPausedReceive");
+  EXPECT_EQ(6, keep_alive_counter().keep_alives());
 }
 
 TEST_F(SerialApiTest, PausedReceiveError) {
   io_handler_ =
       new ReceiveErrorTestIoHandler(device::serial::RECEIVE_ERROR_DEVICE_LOST);
   RunTest("serial_unittest.js", "testPausedReceiveError");
+  EXPECT_EQ(4, keep_alive_counter().keep_alives());
 }
 
 TEST_F(SerialApiTest, ReceiveTimeout) {
   RunTest("serial_unittest.js", "testReceiveTimeout");
+  EXPECT_EQ(4, keep_alive_counter().keep_alives());
 }
 
 TEST_F(SerialApiTest, ReceiveTimeoutAfterSerialization) {
   RunTest("serial_unittest.js", "testReceiveTimeoutAfterSerialization");
+  EXPECT_EQ(3, keep_alive_counter().keep_alives());
 }
 
 TEST_F(SerialApiTest, DisableReceiveTimeout) {
   RunTest("serial_unittest.js", "testDisableReceiveTimeout");
+  EXPECT_EQ(4, keep_alive_counter().keep_alives());
 }
 
 TEST_F(SerialApiTest, ReceiveErrorDisconnected) {
   io_handler_ =
       new ReceiveErrorTestIoHandler(device::serial::RECEIVE_ERROR_DISCONNECTED);
   RunTest("serial_unittest.js", "testReceiveErrorDisconnected");
+  EXPECT_EQ(3, keep_alive_counter().keep_alives());
 }
 
 TEST_F(SerialApiTest, ReceiveErrorDeviceLost) {
   io_handler_ =
       new ReceiveErrorTestIoHandler(device::serial::RECEIVE_ERROR_DEVICE_LOST);
   RunTest("serial_unittest.js", "testReceiveErrorDeviceLost");
+  EXPECT_EQ(3, keep_alive_counter().keep_alives());
 }
 
 TEST_F(SerialApiTest, ReceiveErrorSystemError) {
   io_handler_ =
       new ReceiveErrorTestIoHandler(device::serial::RECEIVE_ERROR_SYSTEM_ERROR);
   RunTest("serial_unittest.js", "testReceiveErrorSystemError");
+  EXPECT_EQ(3, keep_alive_counter().keep_alives());
 }
 
 TEST_F(SerialApiTest, SendErrorDisconnected) {
   io_handler_ =
       new SendErrorTestIoHandler(device::serial::SEND_ERROR_DISCONNECTED);
   RunTest("serial_unittest.js", "testSendErrorDisconnected");
+  EXPECT_EQ(3, keep_alive_counter().keep_alives());
 }
 
 TEST_F(SerialApiTest, SendErrorSystemError) {
   io_handler_ =
       new SendErrorTestIoHandler(device::serial::SEND_ERROR_SYSTEM_ERROR);
   RunTest("serial_unittest.js", "testSendErrorSystemError");
+  EXPECT_EQ(3, keep_alive_counter().keep_alives());
 }
 
 TEST_F(SerialApiTest, DisconnectUnknownConnectionId) {
   RunTest("serial_unittest.js", "testDisconnectUnknownConnectionId");
+  EXPECT_EQ(1, keep_alive_counter().keep_alives());
 }
 
 TEST_F(SerialApiTest, GetInfoUnknownConnectionId) {
   RunTest("serial_unittest.js", "testGetInfoUnknownConnectionId");
+  EXPECT_EQ(1, keep_alive_counter().keep_alives());
 }
 
 TEST_F(SerialApiTest, UpdateUnknownConnectionId) {
   RunTest("serial_unittest.js", "testUpdateUnknownConnectionId");
+  EXPECT_EQ(1, keep_alive_counter().keep_alives());
 }
 
 TEST_F(SerialApiTest, SetControlSignalsUnknownConnectionId) {
   RunTest("serial_unittest.js", "testSetControlSignalsUnknownConnectionId");
+  EXPECT_EQ(1, keep_alive_counter().keep_alives());
 }
 
 TEST_F(SerialApiTest, GetControlSignalsUnknownConnectionId) {
   RunTest("serial_unittest.js", "testGetControlSignalsUnknownConnectionId");
+  EXPECT_EQ(1, keep_alive_counter().keep_alives());
 }
 
 TEST_F(SerialApiTest, FlushUnknownConnectionId) {
   RunTest("serial_unittest.js", "testFlushUnknownConnectionId");
+  EXPECT_EQ(1, keep_alive_counter().keep_alives());
 }
 
 TEST_F(SerialApiTest, SetPausedUnknownConnectionId) {
   RunTest("serial_unittest.js", "testSetPausedUnknownConnectionId");
+  EXPECT_EQ(2, keep_alive_counter().keep_alives());
 }
 
 TEST_F(SerialApiTest, SendUnknownConnectionId) {
   RunTest("serial_unittest.js", "testSendUnknownConnectionId");
+  EXPECT_EQ(1, keep_alive_counter().keep_alives());
 }
 
 }  // namespace extensions