Used oneof in blimp_message.proto

blimp/net/thread_pipe_manager_unittest.cc

Index: blimp/net/thread_pipe_manager_unittest.cc
diff --git a/blimp/net/thread_pipe_manager_unittest.cc b/blimp/net/thread_pipe_manager_unittest.cc
index ed9cc85e5e8bc6aa31cb7773b34f1b2fc72bfda3..28ec56861f9bdc872351f0f8f0e1f67b0149607b 100644
--- a/blimp/net/thread_pipe_manager_unittest.cc
+++ b/blimp/net/thread_pipe_manager_unittest.cc
@@ -10,6 +10,7 @@
 #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"
@@ -24,16 +25,17 @@ using testing::SaveArg;
 namespace blimp {
 namespace {
 
-std::unique_ptr<BlimpMessage> CreateMessage(BlimpMessage::Type type) {
+std::unique_ptr<BlimpMessage> CreateMessage(BlimpMessage::FeatureCase type) {
   std::unique_ptr<BlimpMessage> output(new BlimpMessage);
-  output->set_type(type);
+  SetBlimpMessageType(output.get(), 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_);
   }
@@ -57,7 +59,7 @@ class FakeFeature {
 // |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),
@@ -77,7 +79,7 @@ class FakeFeaturePeer : public BlimpMessageProcessor {
   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)));
@@ -85,7 +87,7 @@ class FakeFeaturePeer : public BlimpMessageProcessor {
       callback.Run(net::OK);
   }
 
-  BlimpMessage::Type type_;
+  BlimpMessage::FeatureCase type_;
   BlimpMessageProcessor* message_processor_ = nullptr;
   scoped_refptr<base::SequencedTaskRunner> task_runner_;
 };
@@ -99,7 +101,7 @@ class FakeBrowserConnectionHandler : public BrowserConnectionHandler {
       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(
@@ -127,9 +129,9 @@ class ThreadPipeManagerTest : public testing::Test {
         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(); }
@@ -157,9 +159,9 @@ class ThreadPipeManagerTest : public testing::Test {
 // |FakeFeaturePeer| loops the message back on |thread_|.
 TEST_F(ThreadPipeManagerTest, MessageSentIsReceived) {
   std::unique_ptr<BlimpMessage> input_message =
-      CreateMessage(BlimpMessage::INPUT);
+      CreateMessage(BlimpMessage::kInput);
   std::unique_ptr<BlimpMessage> tab_control_message =
-      CreateMessage(BlimpMessage::TAB_CONTROL);
+      CreateMessage(BlimpMessage::kTabControl);
 
   EXPECT_CALL(*(input_feature_->incoming_message_processor()),
               MockableProcessMessage(EqualsProto(*input_message), _))