Used oneof in blimp_message.proto

blimp/net/thread_pipe_manager.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/sequenced_task_runner.h"
 #include "blimp/net/blimp_message_processor.h"
 #include "blimp/net/blimp_message_thread_pipe.h"
 #include "blimp/net/browser_connection_handler.h"
 
 namespace blimp {
 
 // IoThreadPipeManager is created on the UI thread, and then used and destroyed
 // on the IO thread.
 // It works with |connection_handler| to register features on the IO thread,
 // and manages IO-thread-side BlimpMessageThreadPipes.
 class IoThreadPipeManager {
  public:
   explicit IoThreadPipeManager(BrowserConnectionHandler* connection_handler);
   virtual ~IoThreadPipeManager();
 
   // Connects message pipes between the specified feature and the network layer,
   // using |incoming_proxy| as the incoming message processor, and connecting
   // |outgoing_pipe| to the actual message sender.
-  void RegisterFeature(BlimpMessage::Type type,
+  void RegisterFeature(BlimpMessage::FeatureCase feature_case,
                        std::unique_ptr<BlimpMessageThreadPipe> outgoing_pipe,
                        std::unique_ptr<BlimpMessageProcessor> incoming_proxy);
 
  private:
   BrowserConnectionHandler* connection_handler_;
 
   // Container for the feature-specific MessageProcessors.
   // IO-side proxy for sending messages to UI thread.
   std::vector<std::unique_ptr<BlimpMessageProcessor>> incoming_proxies_;
 
   // Containers for the MessageProcessors used to write feature-specific
   // messages to the network, and the thread-pipe endpoints through which
   // they are used from the UI thread.
   std::vector<std::unique_ptr<BlimpMessageProcessor>>
       outgoing_message_processors_;
   std::vector<std::unique_ptr<BlimpMessageThreadPipe>> outgoing_pipes_;
 
   DISALLOW_COPY_AND_ASSIGN(IoThreadPipeManager);
 };
 
 IoThreadPipeManager::IoThreadPipeManager(
     BrowserConnectionHandler* connection_handler)
     : connection_handler_(connection_handler) {
   DCHECK(connection_handler_);
 }
 
 IoThreadPipeManager::~IoThreadPipeManager() {}
 
 void IoThreadPipeManager::RegisterFeature(
-    BlimpMessage::Type type,
+    BlimpMessage::FeatureCase feature_case,
     std::unique_ptr<BlimpMessageThreadPipe> outgoing_pipe,
     std::unique_ptr<BlimpMessageProcessor> incoming_proxy) {
   // Registers |incoming_proxy| as the message processor for incoming
-  // messages with |type|. Sets the returned outgoing message processor as the
-  // target of the |outgoing_pipe|.
+  // messages with |feature_case|. Sets the returned outgoing message processor
+  // as the target of the |outgoing_pipe|.
   std::unique_ptr<BlimpMessageProcessor> outgoing_message_processor =
-      connection_handler_->RegisterFeature(type, incoming_proxy.get());
+      connection_handler_->RegisterFeature(feature_case, incoming_proxy.get());
   outgoing_pipe->set_target_processor(outgoing_message_processor.get());
 
   // This object manages the lifetimes of the pipe, proxy and target processor.
   incoming_proxies_.push_back(std::move(incoming_proxy));
   outgoing_pipes_.push_back(std::move(outgoing_pipe));
   outgoing_message_processors_.push_back(std::move(outgoing_message_processor));
 }
 
 ThreadPipeManager::ThreadPipeManager(
     const scoped_refptr<base::SequencedTaskRunner>& io_task_runner,
     const scoped_refptr<base::SequencedTaskRunner>& ui_task_runner,
     BrowserConnectionHandler* connection_handler)
     : io_task_runner_(io_task_runner),
       ui_task_runner_(ui_task_runner),
       io_pipe_manager_(new IoThreadPipeManager(connection_handler)) {}
 
 ThreadPipeManager::~ThreadPipeManager() {
   io_task_runner_->DeleteSoon(FROM_HERE, io_pipe_manager_.release());
 }
 
 std::unique_ptr<BlimpMessageProcessor> ThreadPipeManager::RegisterFeature(
-    BlimpMessage::Type type,
+    BlimpMessage::FeatureCase feature_case,
     BlimpMessageProcessor* incoming_processor) {
   // Creates an outgoing pipe and a proxy for forwarding messages
   // from features on the UI thread to network components on the IO thread.
   std::unique_ptr<BlimpMessageThreadPipe> outgoing_pipe(
       new BlimpMessageThreadPipe(io_task_runner_));
   std::unique_ptr<BlimpMessageProcessor> outgoing_proxy =
       outgoing_pipe->CreateProxy();
 
   // Creates an incoming pipe and a proxy for receiving messages
   // from network components on the IO thread.
   std::unique_ptr<BlimpMessageThreadPipe> incoming_pipe(
       new BlimpMessageThreadPipe(ui_task_runner_));
   incoming_pipe->set_target_processor(incoming_processor);
   std::unique_ptr<BlimpMessageProcessor> incoming_proxy =
       incoming_pipe->CreateProxy();
 
   // Finishes registration on IO thread.
   io_task_runner_->PostTask(
-      FROM_HERE, base::Bind(&IoThreadPipeManager::RegisterFeature,
-                            base::Unretained(io_pipe_manager_.get()), type,
-                            base::Passed(std::move(outgoing_pipe)),
-                            base::Passed(std::move(incoming_proxy))));
+      FROM_HERE,
+      base::Bind(&IoThreadPipeManager::RegisterFeature,
+                 base::Unretained(io_pipe_manager_.get()), feature_case,
+                 base::Passed(std::move(outgoing_pipe)),
+                 base::Passed(std::move(incoming_proxy))));
 
   incoming_pipes_.push_back(std::move(incoming_pipe));
   return outgoing_proxy;
 }
 
 }  // namespace blimp