Mojo: Convert assert()s under mojo/public/cpp/bindings/... to MOJO_DCHECK()s.

mojo/public/cpp/bindings/lib/bindings_serialization.cc

 // Copyright 2013 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/public/cpp/bindings/lib/bindings_serialization.h"
 
-#include <assert.h>
-
 #include "mojo/public/cpp/bindings/lib/bindings_internal.h"
 #include "mojo/public/cpp/bindings/lib/bounds_checker.h"
 #include "mojo/public/cpp/bindings/lib/validation_errors.h"
+#include "mojo/public/cpp/environment/logging.h"
 
 namespace mojo {
 namespace internal {
 
 namespace {
 
 const size_t kAlignment = 8;
 
 template<typename T>
 T AlignImpl(T t) {
@@ skipping 15 matching lines @@
 }
 
 void EncodePointer(const void* ptr, uint64_t* offset) {
   if (!ptr) {
     *offset = 0;
     return;
   }
 
   const char* p_obj = reinterpret_cast<const char*>(ptr);
   const char* p_slot = reinterpret_cast<const char*>(offset);
-  assert(p_obj > p_slot);
+  MOJO_DCHECK(p_obj > p_slot);
 
   *offset = static_cast<uint64_t>(p_obj - p_slot);
 }
 
 const void* DecodePointerRaw(const uint64_t* offset) {
   if (!*offset)
     return NULL;
   return reinterpret_cast<const char*>(offset) + *offset;
 }
 
@@ skipping 10 matching lines @@
   } else {
     handle->set_value(kEncodedInvalidHandleValue);
   }
 }
 
 void DecodeHandle(Handle* handle, std::vector<Handle>* handles) {
   if (handle->value() == kEncodedInvalidHandleValue) {
     *handle = Handle();
     return;
   }
-  assert(handle->value() < handles->size());
+  MOJO_DCHECK(handle->value() < handles->size());
   // Just leave holes in the vector so we don't screw up other indices.
   *handle = FetchAndReset(&handles->at(handle->value()));
 }
 
 bool ValidateStructHeader(const void* data,
                           uint32_t min_num_bytes,
                           uint32_t min_num_fields,
                           BoundsChecker* bounds_checker) {
-  assert(min_num_bytes >= sizeof(StructHeader));
+  MOJO_DCHECK(min_num_bytes >= sizeof(StructHeader));
 
   if (!IsAligned(data)) {
     ReportValidationError(VALIDATION_ERROR_MISALIGNED_OBJECT);
     return false;
   }
   if (!bounds_checker->IsValidRange(data, sizeof(StructHeader))) {
     ReportValidationError(VALIDATION_ERROR_ILLEGAL_MEMORY_RANGE);
     return false;
   }
 
@@ skipping 11 matching lines @@
   if (!bounds_checker->ClaimMemory(data, header->num_bytes)) {
     ReportValidationError(VALIDATION_ERROR_ILLEGAL_MEMORY_RANGE);
     return false;
   }
 
   return true;
 }
 
 }  // namespace internal
 }  // namespace mojo