Fix cast_channel::KeepAliveDelegate DCHECK failure.

extensions/browser/api/cast_channel/keep_alive_delegate_unittest.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 "extensions/browser/api/cast_channel/keep_alive_delegate.h"
 
 #include <stdint.h>
 
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
@@ skipping 146 matching lines @@
   EXPECT_CALL(*inner_delegate_, OnMessage(EqualsProto(other_message)));
   EXPECT_CALL(*inner_delegate_, Start());
   EXPECT_CALL(*ping_timer_, ResetTriggered()).Times(2);
   EXPECT_CALL(*liveness_timer_, ResetTriggered()).Times(2);
 
   keep_alive_->Start();
   keep_alive_->OnMessage(other_message);
   RunPendingTasks();
 }
 
+TEST_F(KeepAliveDelegateTest, TestPassthroughMessagesAfterError) {
+  CastMessage message =
+      KeepAliveDelegate::CreateKeepAliveMessage("NEITHER_PING_NOR_PONG");
+  CastMessage message_after_error =
+      KeepAliveDelegate::CreateKeepAliveMessage("ANOTHER_NOT_PING_NOR_PONG");
+  CastMessage late_ping_message = KeepAliveDelegate::CreateKeepAliveMessage(
+      KeepAliveDelegate::kHeartbeatPingType);
+
+  // Start, process one message, then error-out. KeepAliveDelegate will
+  // automatically stop itself.
+  EXPECT_CALL(*inner_delegate_, Start()).Times(1);
+  EXPECT_CALL(*inner_delegate_, OnMessage(EqualsProto(message)))
+      .Times(1)
+      .RetiresOnSaturation();
+  EXPECT_CALL(*inner_delegate_, OnError(CHANNEL_ERROR_INVALID_MESSAGE));
+  EXPECT_CALL(*ping_timer_, ResetTriggered()).Times(2);
+  EXPECT_CALL(*liveness_timer_, ResetTriggered()).Times(2);
+  EXPECT_CALL(*liveness_timer_, Stop()).Times(1);
+  EXPECT_CALL(*ping_timer_, Stop()).Times(1);

[Wez, 2017/01/04 00:10:17]

Strictly speaking, GMock has undefined behaviour if you mix EXPECT_CALL()
specifications with calls to the object as you're doing here - you should really
specify all the expectations up-front and then have the code that drives the
test execution.

You may want to use Sequence / After to express any ordering constraints on the
API that you also want to enforce.

[miu, 2017/01/12 22:31:27]

My understanding is it always works so long as the EXPECT_CALL() statements are
before the code that will (or shouldn't) cause the calls. But maybe I'm wrong.
Done.
Done.

[Wez, 2017/01/13 22:37:11]

I believe you're right, but strictly it is undefined, so I prefer to try to
stick to the defined approach, which is easier to sanity-check.

+  keep_alive_->Start();
+  keep_alive_->OnMessage(message);
+  RunPendingTasks();
+  keep_alive_->OnError(CHANNEL_ERROR_INVALID_MESSAGE);
+  RunPendingTasks();
+
+  // Process a non-PING/PONG message and expect it to pass through.
+  EXPECT_CALL(*inner_delegate_, OnMessage(EqualsProto(message_after_error)))
+      .Times(1)
+      .RetiresOnSaturation();
+  keep_alive_->OnMessage(message_after_error);
+  RunPendingTasks();
+
+  // Process a late-arriving PING/PONG message, which should have no effect..
+  EXPECT_CALL(*inner_delegate_, OnMessage(EqualsProto(late_ping_message)))
+      .Times(0)
+      .RetiresOnSaturation();
+  keep_alive_->OnMessage(late_ping_message);
+  RunPendingTasks();
+}
+
 }  // namespace
 }  // namespace cast_channel
 }  // namespace api
 }  // namespace extensions