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..a590796a271f704351a199867dec92303044ba23 100644
--- a/blimp/net/thread_pipe_manager_unittest.cc
+++ b/blimp/net/thread_pipe_manager_unittest.cc
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
+#include "blimp/common/create_blimp_message.h"

[Kevin M, 2016/05/02 17:47:48]

Move this to the second block of includes; this top include is reserved
exclusively for thread_pipe_manager.h

[shaktisahu, 2016/05/16 20:19:03]

Done.

 #include "blimp/net/thread_pipe_manager.h"
 
 #include "base/location.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), _))