Update mojo sdk to rev e01f9a49449381a5eb430c1fd88bf2cae73ec35a

mojo/edk/system/handle_table.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/handle_table.h"
 
+#include <limits>
 #include "base/logging.h"
 #include "base/macros.h"
-#include "mojo/edk/system/constants.h"
+#include "mojo/edk/system/configuration.h"
 #include "mojo/edk/system/dispatcher.h"
 
 namespace mojo {
 namespace system {
 
 HandleTable::Entry::Entry() : busy(false) {
 }
 
 HandleTable::Entry::Entry(const scoped_refptr<Dispatcher>& dispatcher)
     : dispatcher(dispatcher), busy(false) {
@@ skipping 32 matching lines @@
   if (it->second.busy)
     return MOJO_RESULT_BUSY;
   *dispatcher = it->second.dispatcher;
   handle_to_entry_map_.erase(it);
 
   return MOJO_RESULT_OK;
 }
 
 MojoHandle HandleTable::AddDispatcher(
     const scoped_refptr<Dispatcher>& dispatcher) {
-  if (handle_to_entry_map_.size() >= kMaxHandleTableSize)
+  if (handle_to_entry_map_.size() >= GetConfiguration().max_handle_table_size)
     return MOJO_HANDLE_INVALID;
   return AddDispatcherNoSizeCheck(dispatcher);
 }
 
 std::pair<MojoHandle, MojoHandle> HandleTable::AddDispatcherPair(
     const scoped_refptr<Dispatcher>& dispatcher0,
     const scoped_refptr<Dispatcher>& dispatcher1) {
-  if (handle_to_entry_map_.size() + 1 >= kMaxHandleTableSize)
+  if (handle_to_entry_map_.size() + 1 >=
+      GetConfiguration().max_handle_table_size)
     return std::make_pair(MOJO_HANDLE_INVALID, MOJO_HANDLE_INVALID);
   return std::make_pair(AddDispatcherNoSizeCheck(dispatcher0),
                         AddDispatcherNoSizeCheck(dispatcher1));
 }
 
 bool HandleTable::AddDispatcherVector(const DispatcherVector& dispatchers,
                                       MojoHandle* handles) {
-  DCHECK_LE(dispatchers.size(), kMaxMessageNumHandles);
+  size_t max_message_num_handles = GetConfiguration().max_message_num_handles;
+  size_t max_handle_table_size = GetConfiguration().max_handle_table_size;
+
+  DCHECK_LE(dispatchers.size(), max_message_num_handles);
   DCHECK(handles);
-  // TODO(vtl): |std::numeric_limits<size_t>::max()| isn't a compile-time
-  // expression in C++03.
-  static_assert(
-      static_cast<uint64_t>(kMaxHandleTableSize) + kMaxMessageNumHandles <
-          (sizeof(size_t) == 8 ? kuint64max
-                               : static_cast<uint64_t>(kuint32max)),
-      "Addition may overflow");
+  DCHECK_LT(
+      static_cast<uint64_t>(max_handle_table_size) + max_message_num_handles,
+      std::numeric_limits<size_t>::max())
+      << "Addition may overflow";
 
-  if (handle_to_entry_map_.size() + dispatchers.size() > kMaxHandleTableSize)
+  if (handle_to_entry_map_.size() + dispatchers.size() > max_handle_table_size)
     return false;
 
   for (size_t i = 0; i < dispatchers.size(); i++) {
     if (dispatchers[i].get()) {
       handles[i] = AddDispatcherNoSizeCheck(dispatchers[i]);
     } else {
       LOG(WARNING) << "Invalid dispatcher at index " << i;
       handles[i] = MOJO_HANDLE_INVALID;
     }
   }
   return true;
 }
 
 MojoResult HandleTable::MarkBusyAndStartTransport(
     MojoHandle disallowed_handle,
     const MojoHandle* handles,
     uint32_t num_handles,
     std::vector<DispatcherTransport>* transports) {
   DCHECK_NE(disallowed_handle, MOJO_HANDLE_INVALID);
   DCHECK(handles);
-  DCHECK_LE(num_handles, kMaxMessageNumHandles);
+  DCHECK_LE(num_handles, GetConfiguration().max_message_num_handles);
   DCHECK(transports);
   DCHECK_EQ(transports->size(), num_handles);
 
   std::vector<Entry*> entries(num_handles);
 
   // First verify all the handles and get their dispatchers.
   uint32_t i;
   MojoResult error_result = MOJO_RESULT_INTERNAL;
   for (i = 0; i < num_handles; i++) {
     // Sending your own handle is not allowed (and, for consistency, returns
@@ skipping 60 matching lines @@
     }
     return error_result;
   }
 
   return MOJO_RESULT_OK;
 }
 
 MojoHandle HandleTable::AddDispatcherNoSizeCheck(
     const scoped_refptr<Dispatcher>& dispatcher) {
   DCHECK(dispatcher.get());
-  DCHECK_LT(handle_to_entry_map_.size(), kMaxHandleTableSize);
+  DCHECK_LT(handle_to_entry_map_.size(),
+            GetConfiguration().max_handle_table_size);
   DCHECK_NE(next_handle_, MOJO_HANDLE_INVALID);
 
   // TODO(vtl): Maybe we want to do something different/smarter. (Or maybe try
   // assigning randomly?)
   while (handle_to_entry_map_.find(next_handle_) !=
          handle_to_entry_map_.end()) {
     next_handle_++;
     if (next_handle_ == MOJO_HANDLE_INVALID)
       next_handle_++;
   }
 
   MojoHandle new_handle = next_handle_;
   handle_to_entry_map_[new_handle] = Entry(dispatcher);
 
   next_handle_++;
   if (next_handle_ == MOJO_HANDLE_INVALID)
     next_handle_++;
 
   return new_handle;
 }
 
 void HandleTable::RemoveBusyHandles(const MojoHandle* handles,
                                     uint32_t num_handles) {
   DCHECK(handles);
-  DCHECK_LE(num_handles, kMaxMessageNumHandles);
+  DCHECK_LE(num_handles, GetConfiguration().max_message_num_handles);
 
   for (uint32_t i = 0; i < num_handles; i++) {
     HandleToEntryMap::iterator it = handle_to_entry_map_.find(handles[i]);
     DCHECK(it != handle_to_entry_map_.end());
     DCHECK(it->second.busy);
     it->second.busy = false;  // For the sake of a |DCHECK()|.
     handle_to_entry_map_.erase(it);
   }
 }
 
 void HandleTable::RestoreBusyHandles(const MojoHandle* handles,
                                      uint32_t num_handles) {
   DCHECK(handles);
-  DCHECK_LE(num_handles, kMaxMessageNumHandles);
+  DCHECK_LE(num_handles, GetConfiguration().max_message_num_handles);
 
   for (uint32_t i = 0; i < num_handles; i++) {
     HandleToEntryMap::iterator it = handle_to_entry_map_.find(handles[i]);
     DCHECK(it != handle_to_entry_map_.end());
     DCHECK(it->second.busy);
     it->second.busy = false;
   }
 }
 
 }  // namespace system
 }  // namespace mojo