Used oneof in blimp_message.proto

blimp/net/blimp_message_multiplexer.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_multiplexer.h"
 
 #include "base/logging.h"
 #include "base/memory/ptr_util.h"
+#include "blimp/common/create_blimp_message.h"
 #include "blimp/common/proto/blimp_message.pb.h"
 #include "blimp/net/blimp_message_processor.h"
 
 namespace blimp {
 namespace {
 
 class MultiplexedSender : public BlimpMessageProcessor {
  public:
   MultiplexedSender(base::WeakPtr<BlimpMessageProcessor> output_processor,
-                    BlimpMessage::Type type);
+                    BlimpMessage::FeatureCase type);
   ~MultiplexedSender() override;
 
   // BlimpMessageProcessor implementation.
   // |message.type|, if set, must match the sender's type.
   void ProcessMessage(std::unique_ptr<BlimpMessage> message,
                       const net::CompletionCallback& callback) override;
 
  private:
   base::WeakPtr<BlimpMessageProcessor> output_processor_;
-  BlimpMessage::Type type_;
+  BlimpMessage::FeatureCase type_;
 
   DISALLOW_COPY_AND_ASSIGN(MultiplexedSender);
 };
 
 MultiplexedSender::MultiplexedSender(
     base::WeakPtr<BlimpMessageProcessor> output_processor,
-    BlimpMessage::Type type)
+    BlimpMessage::FeatureCase type)
     : output_processor_(output_processor), type_(type) {}
 
 MultiplexedSender::~MultiplexedSender() {}
 
 void MultiplexedSender::ProcessMessage(
     std::unique_ptr<BlimpMessage> message,
     const net::CompletionCallback& callback) {
-  if (message->has_type()) {
-    DCHECK_EQ(type_, message->type());
+  if (message->feature_case() != BlimpMessage::FEATURE_NOT_SET) {
+    DCHECK_EQ(type_, message->feature_case());
   } else {
-    message->set_type(type_);
+    SetBlimpMessageType(message.get(), type_);

[Kevin M, 2016/05/16 22:58:02]

We should probably standardize on what message format is acceptable. Instead of
coercing a message to the appropriate type, can we just DCHECK if the
message->feature_case() == type_ and require that callers only provide well
formed messages?

[shaktisahu, 2016/05/17 01:21:32]

Done.

   }
   output_processor_->ProcessMessage(std::move(message), callback);
 }
 
 }  // namespace
 
 BlimpMessageMultiplexer::BlimpMessageMultiplexer(
     BlimpMessageProcessor* output_processor)
     : output_weak_factory_(output_processor) {}
 
 BlimpMessageMultiplexer::~BlimpMessageMultiplexer() {}
 
 std::unique_ptr<BlimpMessageProcessor>
-BlimpMessageMultiplexer::CreateSenderForType(BlimpMessage::Type type) {
+BlimpMessageMultiplexer::CreateSenderForType(BlimpMessage::FeatureCase type) {
   return base::WrapUnique(
       new MultiplexedSender(output_weak_factory_.GetWeakPtr(), type));
 }
 }  // namespace blimp