Update mojo sdk to rev e01f9a49449381a5eb430c1fd88bf2cae73ec35a

mojo/edk/system/transport_data.cc

 // Copyright 2014 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/transport_data.h"
 
 #include <string.h>
 
 #include "base/compiler_specific.h"
 #include "base/logging.h"
 #include "mojo/edk/system/channel.h"
-#include "mojo/edk/system/constants.h"
+#include "mojo/edk/system/configuration.h"
 #include "mojo/edk/system/message_in_transit.h"
 
 namespace mojo {
 namespace system {
 
 // The maximum amount of space needed per platform handle.
 // (|{Channel,RawChannel}::GetSerializedPlatformHandleSize()| should always
 // return a value which is at most this. This is only used to calculate
 // |TransportData::kMaxBufferSize|. This value should be a multiple of the
 // alignment in order to simplify calculations, even though the actual amount of
 // space needed need not be a multiple of the alignment.
 const size_t kMaxSizePerPlatformHandle = 8;
 static_assert(kMaxSizePerPlatformHandle % MessageInTransit::kMessageAlignment ==
                   0,
               "kMaxSizePerPlatformHandle not a multiple of alignment");
 
 STATIC_CONST_MEMBER_DEFINITION const size_t
     TransportData::kMaxSerializedDispatcherSize;
 STATIC_CONST_MEMBER_DEFINITION const size_t
     TransportData::kMaxSerializedDispatcherPlatformHandles;
 
 // static
-const size_t TransportData::kMaxPlatformHandles =
-    kMaxMessageNumHandles * kMaxSerializedDispatcherPlatformHandles;
+size_t TransportData::GetMaxBufferSize() {
+  // In additional to the header, for each attached (Mojo) handle there'll be a
+  // handle table entry and serialized dispatcher data.
+  return sizeof(Header) +
+         GetConfiguration().max_message_num_handles *
+             (sizeof(HandleTableEntry) + kMaxSerializedDispatcherSize) +
+         GetMaxPlatformHandles() * kMaxSizePerPlatformHandle;
+}
 
-// In additional to the header, for each attached (Mojo) handle there'll be a
-// handle table entry and serialized dispatcher data.
-// Note: This definition must follow the one for |kMaxPlatformHandles|;
-// otherwise, we get a static initializer with gcc (but not clang).
 // static
-const size_t TransportData::kMaxBufferSize =
-    sizeof(Header) +
-    kMaxMessageNumHandles *
-        (sizeof(HandleTableEntry) + kMaxSerializedDispatcherSize) +
-    kMaxPlatformHandles * kMaxSizePerPlatformHandle;
+size_t TransportData::GetMaxPlatformHandles() {
+  return GetConfiguration().max_message_num_handles *
+         kMaxSerializedDispatcherPlatformHandles;
+}
 
 struct TransportData::PrivateStructForCompileAsserts {
   static_assert(sizeof(Header) % MessageInTransit::kMessageAlignment == 0,
                 "sizeof(MessageInTransit::Header) not a multiple of alignment");
   static_assert(kMaxSerializedDispatcherSize %
                         MessageInTransit::kMessageAlignment ==
                     0,
                 "kMaxSerializedDispatcherSize not a multiple of alignment");
   static_assert(sizeof(HandleTableEntry) %
                         MessageInTransit::kMessageAlignment ==
@@ skipping 25 matching lines @@
 #endif
   for (size_t i = 0; i < num_handles; i++) {
     if (Dispatcher* dispatcher = (*dispatchers)[i].get()) {
       size_t max_size = 0;
       size_t max_platform_handles = 0;
       Dispatcher::TransportDataAccess::StartSerialize(
           dispatcher, channel, &max_size, &max_platform_handles);
 
       DCHECK_LE(max_size, kMaxSerializedDispatcherSize);
       estimated_size += MessageInTransit::RoundUpMessageAlignment(max_size);
-      DCHECK_LE(estimated_size, kMaxBufferSize);
+      DCHECK_LE(estimated_size, GetMaxBufferSize());
 
       DCHECK_LE(max_platform_handles, kMaxSerializedDispatcherPlatformHandles);
       estimated_num_platform_handles += max_platform_handles;
-      DCHECK_LE(estimated_num_platform_handles, kMaxPlatformHandles);
+      DCHECK_LE(estimated_num_platform_handles, GetMaxPlatformHandles());
 
 #if DCHECK_IS_ON
       all_max_sizes[i] = max_size;
       all_max_platform_handles[i] = max_platform_handles;
 #endif
     }
   }
 
   size_t size_per_platform_handle = 0;
   if (estimated_num_platform_handles > 0) {
     size_per_platform_handle = channel->GetSerializedPlatformHandleSize();
     DCHECK_LE(size_per_platform_handle, kMaxSizePerPlatformHandle);
     estimated_size += estimated_num_platform_handles * size_per_platform_handle;
     estimated_size = MessageInTransit::RoundUpMessageAlignment(estimated_size);
-    DCHECK_LE(estimated_size, kMaxBufferSize);
+    DCHECK_LE(estimated_size, GetMaxBufferSize());
   }
 
   buffer_.reset(static_cast<char*>(
       base::AlignedAlloc(estimated_size, MessageInTransit::kMessageAlignment)));
   // Entirely clear out the secondary buffer, since then we won't have to worry
   // about clearing padding or unused space (e.g., if a dispatcher fails to
   // serialize).
   memset(buffer_.get(), 0, estimated_size);
 
   if (estimated_num_platform_handles > 0) {
@@ skipping 18 matching lines @@
     }
 
 #if DCHECK_IS_ON
     size_t old_platform_handles_size =
         platform_handles_ ? platform_handles_->size() : 0;
 #endif
 
     void* destination = buffer_.get() + current_offset;
     size_t actual_size = 0;
     if (Dispatcher::TransportDataAccess::EndSerializeAndClose(
-            dispatcher,
-            channel,
-            destination,
-            &actual_size,
+            dispatcher, channel, destination, &actual_size,
             platform_handles_.get())) {
       handle_table[i].type = static_cast<int32_t>(dispatcher->GetType());
       handle_table[i].offset = static_cast<uint32_t>(current_offset);
       handle_table[i].size = static_cast<uint32_t>(actual_size);
 // (Okay to not set |unused| since we cleared the entire buffer.)
 
 #if DCHECK_IS_ON
       DCHECK_LE(actual_size, all_max_sizes[i]);
       DCHECK_LE(platform_handles_
                     ? (platform_handles_->size() - old_platform_handles_size)
@@ skipping 44 matching lines @@
 // static
 const char* TransportData::ValidateBuffer(
     size_t serialized_platform_handle_size,
     const void* buffer,
     size_t buffer_size) {
   DCHECK(buffer);
   DCHECK_GT(buffer_size, 0u);
 
   // Always make sure that the buffer size is sane; if it's not, someone's
   // messing with us.
-  if (buffer_size < sizeof(Header) || buffer_size > kMaxBufferSize ||
+  if (buffer_size < sizeof(Header) || buffer_size > GetMaxBufferSize() ||
       buffer_size % MessageInTransit::kMessageAlignment != 0)
     return "Invalid message secondary buffer size";
 
   const Header* header = static_cast<const Header*>(buffer);
   const size_t num_handles = header->num_handles;
 
 #if !defined(OS_POSIX)
   // On POSIX, we send control messages with platform handles (but no handles)
   // attached (see the comments for
   // |TransportData(embedder::ScopedPlatformHandleVectorPtr)|. (This check isn't
   // important security-wise anyway.)
   if (num_handles == 0)
     return "Message has no handles attached, but secondary buffer present";
 #endif
 
   // Sanity-check |num_handles| (before multiplying it against anything).
-  if (num_handles > kMaxMessageNumHandles)
+  if (num_handles > GetConfiguration().max_message_num_handles)
     return "Message handle payload too large";
 
   if (buffer_size < sizeof(Header) + num_handles * sizeof(HandleTableEntry))
     return "Message secondary buffer too small";
 
   if (header->num_platform_handles == 0) {
     // Then |platform_handle_table_offset| should also be zero.
     if (header->platform_handle_table_offset != 0) {
       return "Message has no handles attached, but platform handle table "
              "present";
@@ skipping 90 matching lines @@
     const void* source = static_cast<const char*>(buffer) + offset;
     (*dispatchers)[i] = Dispatcher::TransportDataAccess::Deserialize(
         channel, handle_table[i].type, source, size, platform_handles.get());
   }
 
   return dispatchers.Pass();
 }
 
 }  // namespace system
 }  // namespace mojo