Used oneof in blimp_message.proto

blimp/net/thread_pipe_manager_unittest.cc

 // Copyright 2016 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/thread_pipe_manager.h"
 
 #include "base/location.h"
 #include "base/memory/ptr_util.h"
 #include "base/memory/ref_counted.h"
 #include "base/message_loop/message_loop.h"
 #include "base/threading/sequenced_task_runner_handle.h"
 #include "base/threading/thread.h"
+#include "blimp/common/create_blimp_message.h"
 #include "blimp/net/blimp_message_thread_pipe.h"
 #include "blimp/net/browser_connection_handler.h"
 #include "blimp/net/test_common.h"
 #include "net/base/net_errors.h"
 #include "net/base/test_completion_callback.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using testing::_;
 using testing::SaveArg;
 
 namespace blimp {
 namespace {
 
-std::unique_ptr<BlimpMessage> CreateMessage(BlimpMessage::Type type) {
-  std::unique_ptr<BlimpMessage> output(new BlimpMessage);
-  output->set_type(type);
-  return output;
-}
-
 // A feature that registers itself with ThreadPipeManager.
 class FakeFeature {
  public:
-  FakeFeature(BlimpMessage::Type type, ThreadPipeManager* pipe_manager_) {
+  FakeFeature(BlimpMessage::FeatureCase type,
+              ThreadPipeManager* pipe_manager_) {
     outgoing_message_processor_ =
         pipe_manager_->RegisterFeature(type, &incoming_message_processor_);
   }
 
   ~FakeFeature() {}
 
   BlimpMessageProcessor* outgoing_message_processor() {
     return outgoing_message_processor_.get();
   }
 
   MockBlimpMessageProcessor* incoming_message_processor() {
     return &incoming_message_processor_;
   }
 
  private:
   testing::StrictMock<MockBlimpMessageProcessor> incoming_message_processor_;
   std::unique_ptr<BlimpMessageProcessor> outgoing_message_processor_;
 };
 
 // A feature peer on |thread_| that forwards incoming messages to
 // |message_processor|.
 class FakeFeaturePeer : public BlimpMessageProcessor {
  public:
-  FakeFeaturePeer(BlimpMessage::Type type,
+  FakeFeaturePeer(BlimpMessage::FeatureCase type,
                   BlimpMessageProcessor* message_processor,
                   const scoped_refptr<base::SequencedTaskRunner>& task_runner)
       : type_(type),
         message_processor_(message_processor),
         task_runner_(task_runner) {}
 
   ~FakeFeaturePeer() override {}
 
  private:
   void ForwardMessage(std::unique_ptr<BlimpMessage> message) {
     DCHECK(task_runner_->RunsTasksOnCurrentThread());
     message_processor_->ProcessMessage(std::move(message),
                                        net::CompletionCallback());
   }
 
   // BlimpMessageProcessor implementation.
   void ProcessMessage(std::unique_ptr<BlimpMessage> message,
                       const net::CompletionCallback& callback) override {
     DCHECK(task_runner_->RunsTasksOnCurrentThread());
-    ASSERT_EQ(type_, message->type());
+    ASSERT_EQ(type_, message->feature_case());
     base::MessageLoop::current()->PostTask(
         FROM_HERE, base::Bind(&FakeFeaturePeer::ForwardMessage,
                               base::Unretained(this), base::Passed(&message)));
     if (!callback.is_null())
       callback.Run(net::OK);
   }
 
-  BlimpMessage::Type type_;
+  BlimpMessage::FeatureCase type_;
   BlimpMessageProcessor* message_processor_ = nullptr;
   scoped_refptr<base::SequencedTaskRunner> task_runner_;
 };
 
 // A browser connection handler that returns FakeFeaturePeer to allow it
 // forwarding message back so that FakeFeature can check message it receives
 // with one it just sent.
 class FakeBrowserConnectionHandler : public BrowserConnectionHandler {
  public:
   FakeBrowserConnectionHandler(
       const scoped_refptr<base::SequencedTaskRunner>& task_runner)
       : task_runner_(task_runner) {}
   std::unique_ptr<BlimpMessageProcessor> RegisterFeature(
-      BlimpMessage::Type type,
+      BlimpMessage::FeatureCase type,
       BlimpMessageProcessor* incoming_processor) override {
     DCHECK(task_runner_->RunsTasksOnCurrentThread());
     return base::WrapUnique(
         new FakeFeaturePeer(type, incoming_processor, task_runner_));
   }
 
  private:
   scoped_refptr<base::SequencedTaskRunner> task_runner_;
 };
 
 }  // namespace
 
 class ThreadPipeManagerTest : public testing::Test {
  public:
   ThreadPipeManagerTest() : thread_("IoThread") {}
 
   ~ThreadPipeManagerTest() override {}
 
   void SetUp() override {
     ASSERT_TRUE(thread_.Start());
     connection_handler_ = base::WrapUnique(
         new FakeBrowserConnectionHandler(thread_.task_runner()));
     pipe_manager_ = base::WrapUnique(new ThreadPipeManager(
         thread_.task_runner(), base::SequencedTaskRunnerHandle::Get(),
         connection_handler_.get()));
 
     input_feature_.reset(
-        new FakeFeature(BlimpMessage::INPUT, pipe_manager_.get()));
+        new FakeFeature(BlimpMessage::kInput, pipe_manager_.get()));
     tab_control_feature_.reset(
-        new FakeFeature(BlimpMessage::TAB_CONTROL, pipe_manager_.get()));
+        new FakeFeature(BlimpMessage::kTabControl, pipe_manager_.get()));
   }
 
   void TearDown() override { SynchronizeWithThread(); }
 
   // Synchronize with |thread_| to ensure that any pending work is done.
   void SynchronizeWithThread() {
     net::TestCompletionCallback cb;
     thread_.task_runner()->PostTaskAndReply(FROM_HERE,
                                             base::Bind(&base::DoNothing),
                                             base::Bind(cb.callback(), net::OK));
     ASSERT_EQ(net::OK, cb.WaitForResult());
   }
 
  protected:
   base::MessageLoop message_loop_;
   std::unique_ptr<BrowserConnectionHandler> connection_handler_;
   std::unique_ptr<ThreadPipeManager> pipe_manager_;
   base::Thread thread_;
 
   std::unique_ptr<FakeFeature> input_feature_;
   std::unique_ptr<FakeFeature> tab_control_feature_;
 };
 
 // Features send out message and receive the same message due to
 // |FakeFeaturePeer| loops the message back on |thread_|.
 TEST_F(ThreadPipeManagerTest, MessageSentIsReceived) {
-  std::unique_ptr<BlimpMessage> input_message =
-      CreateMessage(BlimpMessage::INPUT);
+  InputMessage* input;
+  TabControlMessage* tab_control;

[Wez, 2016/05/18 01:53:31]

nit: Move this to come immediately before tab_control_message.

[shaktisahu, 2016/05/18 03:55:42]

Done.

+  std::unique_ptr<BlimpMessage> input_message = CreateBlimpMessage(&input);
   std::unique_ptr<BlimpMessage> tab_control_message =
-      CreateMessage(BlimpMessage::TAB_CONTROL);
+      CreateBlimpMessage(&tab_control);
 
   EXPECT_CALL(*(input_feature_->incoming_message_processor()),
               MockableProcessMessage(EqualsProto(*input_message), _))
       .RetiresOnSaturation();
   EXPECT_CALL(*(tab_control_feature_->incoming_message_processor()),
               MockableProcessMessage(EqualsProto(*tab_control_message), _))
       .RetiresOnSaturation();
 
   net::TestCompletionCallback cb1;
   input_feature_->outgoing_message_processor()->ProcessMessage(
       std::move(input_message), cb1.callback());
   net::TestCompletionCallback cb2;
   tab_control_feature_->outgoing_message_processor()->ProcessMessage(
       std::move(tab_control_message), cb2.callback());
 
   EXPECT_EQ(net::OK, cb1.WaitForResult());
   EXPECT_EQ(net::OK, cb2.WaitForResult());
 }
 
 }  // namespace blimp