Used oneof in blimp_message.proto

blimp/net/blimp_message_checkpointer_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 "blimp/net/blimp_message_checkpointer.h"
 
 #include "base/memory/ptr_util.h"
 #include "base/memory/ref_counted.h"
 #include "base/test/test_mock_time_task_runner.h"
 #include "base/threading/thread_task_runner_handle.h"
@@ skipping 14 matching lines @@
 class MockCheckpointObserver : public BlimpMessageCheckpointObserver {
  public:
   MockCheckpointObserver() {}
   ~MockCheckpointObserver() override {}
 
   MOCK_METHOD1(OnMessageCheckpoint, void(int64_t));
 };
 
 }  // namespace
 
-static std::unique_ptr<BlimpMessage> CreateExpectedAckMessage(int64_t id) {
-  std::unique_ptr<BlimpMessage> message = base::WrapUnique(new BlimpMessage);
-  message->set_type(BlimpMessage::PROTOCOL_CONTROL);
-  ProtocolControlMessage* protocol_control =
-      message->mutable_protocol_control();
-  protocol_control->set_type(ProtocolControlMessage::CHECKPOINT_ACK);
-  CheckpointAckMessage* checkpoint_ack =
-      protocol_control->mutable_checkpoint_ack();
-  checkpoint_ack->set_checkpoint_id(id);
-  return message;
-}
-
 class BlimpMessageCheckpointerTest : public testing::Test {
  public:
   BlimpMessageCheckpointerTest()
       : runner_(new base::TestMockTimeTaskRunner), runner_handle_(runner_) {}
 
   ~BlimpMessageCheckpointerTest() override {}
 
   int64_t SimulateIncomingMessage() {
-    std::unique_ptr<BlimpMessage> message(new BlimpMessage);
+    InputMessage* input;
+    std::unique_ptr<BlimpMessage> message(CreateBlimpMessage(&input));
     message->set_message_id(++message_id_);
-    message->set_type(BlimpMessage::INPUT);
     checkpointer_->ProcessMessage(
         std::move(message),
         base::Bind(&BlimpMessageCheckpointerTest::IncomingCompletionCallback,
                    base::Unretained(this)));
     return message_id_;
   }
 
   void SetUp() override {
     checkpointer_ = base::WrapUnique(new BlimpMessageCheckpointer(
         &incoming_processor_, &outgoing_processor_, &checkpoint_observer_));
@@ skipping 38 matching lines @@
 
   // Delete the checkpointer, then simulate completion of processing.
   // TestCompletionCallback should not fire, so no expectations.
   checkpointer_ = nullptr;
   captured_cb_.Run(net::OK);
 }
 
 TEST_F(BlimpMessageCheckpointerTest, SingleMessageAck) {
   EXPECT_CALL(incoming_processor_, MockableProcessMessage(_, _))
       .WillOnce(SaveArg<1>(&captured_cb_));
-  std::unique_ptr<BlimpMessage> expected_ack = CreateExpectedAckMessage(1);
+  std::unique_ptr<BlimpMessage> expected_ack = CreateCheckpointAckMessage(1);
   EXPECT_CALL(outgoing_processor_,
               MockableProcessMessage(EqualsProto(*expected_ack), _));
   EXPECT_CALL(*this, IncomingCompletionCallback(net::OK));
 
   // Simulate an incoming message.
   SimulateIncomingMessage();
 
   // Fast-forward time to verify that an ACK message is sent.
   captured_cb_.Run(net::OK);
   runner_->FastForwardBy(base::TimeDelta::FromSeconds(2));
 }
 
 TEST_F(BlimpMessageCheckpointerTest, BatchMessageAck) {
   EXPECT_CALL(incoming_processor_, MockableProcessMessage(_, _))
       .Times(10)
       .WillRepeatedly(SaveArg<1>(&captured_cb_));
-  std::unique_ptr<BlimpMessage> expected_ack = CreateExpectedAckMessage(10);
+  std::unique_ptr<BlimpMessage> expected_ack = CreateCheckpointAckMessage(10);
   EXPECT_CALL(outgoing_processor_,
               MockableProcessMessage(EqualsProto(*expected_ack), _));
   EXPECT_CALL(*this, IncomingCompletionCallback(net::OK)).Times(10);
 
   // Simulate ten incoming messages.
   for (int i = 0; i < 10; ++i) {
     SimulateIncomingMessage();
     captured_cb_.Run(net::OK);
   }
 
   // Fast-forward time to verify that only a single ACK message is sent.
   runner_->FastForwardBy(base::TimeDelta::FromSeconds(2));
 }
 
 TEST_F(BlimpMessageCheckpointerTest, MultipleAcks) {
   EXPECT_CALL(incoming_processor_, MockableProcessMessage(_, _))
       .Times(2)
       .WillRepeatedly(SaveArg<1>(&captured_cb_));
-  std::unique_ptr<BlimpMessage> expected_ack1 = CreateExpectedAckMessage(1);
+  std::unique_ptr<BlimpMessage> expected_ack1 = CreateCheckpointAckMessage(1);
   EXPECT_CALL(outgoing_processor_,
               MockableProcessMessage(EqualsProto(*expected_ack1), _));
-  std::unique_ptr<BlimpMessage> expected_ack2 = CreateExpectedAckMessage(2);
+  std::unique_ptr<BlimpMessage> expected_ack2 = CreateCheckpointAckMessage(2);
   EXPECT_CALL(outgoing_processor_,
               MockableProcessMessage(EqualsProto(*expected_ack2), _));
   EXPECT_CALL(*this, IncomingCompletionCallback(net::OK)).Times(2);
 
   // Simulate an incoming messages and fast-forward to get the ACK.
   SimulateIncomingMessage();
   captured_cb_.Run(net::OK);
   runner_->FastForwardBy(base::TimeDelta::FromSeconds(2));
 
   // And do it again to verify we get a fresh ACK.
   SimulateIncomingMessage();
   captured_cb_.Run(net::OK);
   runner_->FastForwardBy(base::TimeDelta::FromSeconds(2));
 }
 
 TEST_F(BlimpMessageCheckpointerTest, IncomingAckMessage) {
   EXPECT_CALL(*this, IncomingCompletionCallback(net::OK));
   EXPECT_CALL(checkpoint_observer_, OnMessageCheckpoint(10));
 
   // Simulate an incoming message.
   std::unique_ptr<BlimpMessage> ack_message = CreateCheckpointAckMessage(10);
   checkpointer_->ProcessMessage(
       std::move(ack_message),
       base::Bind(&BlimpMessageCheckpointerTest::IncomingCompletionCallback,
                  base::Unretained(this)));
 }
 
 }  // namespace blimp