Making the Mojo Channel Messages legacy mode dynamic.

mojo/edk/system/channel.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 <stddef.h>
 #include <string.h>
 
 #include <algorithm>
 #include <limits>
 #include <utility>
 
 #include "base/macros.h"
 #include "base/memory/aligned_memory.h"
 #include "base/process/process_handle.h"
+#include "mojo/edk/embedder/embedder_internal.h"
 #include "mojo/edk/embedder/platform_handle.h"
 
 #if defined(OS_MACOSX) && !defined(OS_IOS)
 #include "base/mac/mach_logging.h"
 #elif defined(OS_WIN)
 #include "base/win/win_util.h"
 #endif
 
 namespace mojo {
 namespace edk {
@@ skipping 11 matching lines @@
               "LegacyHeader must be 8 bytes on ChromeOS and Android");
 
 static_assert(offsetof(Channel::Message::LegacyHeader, num_bytes) ==
                   offsetof(Channel::Message::Header, num_bytes),
               "num_bytes should be at the same offset in both Header structs.");
 static_assert(offsetof(Channel::Message::LegacyHeader, message_type) ==
                   offsetof(Channel::Message::Header, message_type),
               "message_type should be at the same offset in both Header "
               "structs.");
 
+bool g_use_legacy_protocol = false;
+
 }  // namespace
 
 const size_t kReadBufferSize = 4096;
 const size_t kMaxUnusedReadBufferCapacity = 4096;
 const size_t kMaxChannelMessageSize = 256 * 1024 * 1024;
 const size_t kMaxAttachedHandles = 128;
 
 Channel::Message::Message(size_t payload_size, size_t max_handles)
-#if defined(MOJO_EDK_LEGACY_PROTOCOL)
-    : Message(payload_size, max_handles, MessageType::NORMAL_LEGACY) {
-}
-#else
-    : Message(payload_size, max_handles, MessageType::NORMAL) {
-}
-#endif
+    : Message(payload_size,
+              max_handles,
+              g_use_legacy_protocol ? MessageType::NORMAL_LEGACY
+                                    : MessageType::NORMAL) {}
 
 Channel::Message::Message(size_t payload_size,
                           size_t max_handles,
                           MessageType message_type)
     : max_handles_(max_handles) {
   DCHECK_LE(max_handles_, kMaxAttachedHandles);
 
   const bool is_legacy_message = (message_type == MessageType::NORMAL_LEGACY);
   size_t extra_header_size = 0;
 #if defined(OS_WIN)
@@ skipping 315 matching lines @@
         ++it;
       }
     }
   }
   return std::move(handle_vector_);
 #else
   return std::move(handle_vector_);
 #endif
 }
 
+// static
+void Channel::Message::SetUseLegacyTransportProtocol(bool use_legacy_protocol) {
+  // Make sure this is called before mojo::edk::Init() is called.
+  DCHECK(!internal::g_core);
+  g_use_legacy_protocol = use_legacy_protocol;
+}
+
 #if defined(OS_WIN)
 // static
 bool Channel::Message::RewriteHandles(base::ProcessHandle from_process,
                                       base::ProcessHandle to_process,
                                       PlatformHandleVector* handles) {
   bool success = true;
   for (size_t i = 0; i < handles->size(); ++i) {
     if (!(*handles)[i].is_valid()) {
       DLOG(ERROR) << "Refusing to duplicate invalid handle.";
       continue;
@@ skipping 266 matching lines @@
 
 bool Channel::OnControlMessage(Message::MessageType message_type,
                                const void* payload,
                                size_t payload_size,
                                ScopedPlatformHandleVectorPtr handles) {
   return false;
 }
 
 }  // namespace edk
 }  // namespace mojo