Adding a new message type to the Mojo channel.

mojo/edk/system/channel_posix.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 "mojo/edk/system/channel.h"
 
 #include <errno.h>
 #include <sys/socket.h>
 
 #include <algorithm>
@@ skipping 369 matching lines @@
           std::vector<int> fds;
           for (auto& handle : *handles)
             fds.push_back(handle.handle);
           {
             base::AutoLock l(handles_to_close_lock_);
             for (auto& handle : *handles)
               handles_to_close_->push_back(handle);
           }
           MessagePtr fds_message(
               new Channel::Message(sizeof(fds[0]) * fds.size(), 0,
-                                   Message::Header::MessageType::HANDLES_SENT));
+                                   Message::MessageType::HANDLES_SENT));
           memcpy(fds_message->mutable_payload(), fds.data(),
                  sizeof(fds[0]) * fds.size());
           outgoing_messages_.emplace_back(std::move(fds_message), 0);
           handles->clear();
 #else
           handles.reset();
 #endif  // defined(OS_MACOSX)
         }
       } else {
         result = PlatformChannelWrite(handle_.get(), message_view.data(),
@@ skipping 54 matching lines @@
           messages.pop_back();
         }
         return true;
       }
     }
 
     return true;
   }
 
 #if defined(OS_MACOSX)
-  bool OnControlMessage(Message::Header::MessageType message_type,
+  bool OnControlMessage(Message::MessageType message_type,
                         const void* payload,
                         size_t payload_size,
                         ScopedPlatformHandleVectorPtr handles) override {
     switch (message_type) {
-      case Message::Header::MessageType::HANDLES_SENT: {
+      case Message::MessageType::HANDLES_SENT: {
         if (payload_size == 0)
           break;
         MessagePtr message(new Channel::Message(
-            payload_size, 0, Message::Header::MessageType::HANDLES_SENT_ACK));
+            payload_size, 0, Message::MessageType::HANDLES_SENT_ACK));
         memcpy(message->mutable_payload(), payload, payload_size);
         Write(std::move(message));
         return true;
       }
 
-      case Message::Header::MessageType::HANDLES_SENT_ACK: {
+      case Message::MessageType::HANDLES_SENT_ACK: {
         size_t num_fds = payload_size / sizeof(int);
         if (num_fds == 0 || payload_size % sizeof(int) != 0)
           break;
 
         const int* fds = reinterpret_cast<const int*>(payload);
         if (!CloseHandles(fds, num_fds))
           break;
         return true;
       }
 
@@ skipping 70 matching lines @@
 // static
 scoped_refptr<Channel> Channel::Create(
     Delegate* delegate,
     ScopedPlatformHandle platform_handle,
     scoped_refptr<base::TaskRunner> io_task_runner) {
   return new ChannelPosix(delegate, std::move(platform_handle), io_task_runner);
 }
 
 }  // namespace edk
 }  // namespace mojo