[mojo-sdk] Replace assert() usage in bindings with DCHECK.

mojo/public/cpp/system/message_pipe.h

 // 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.
 
 // This file provides a C++ wrapping around the Mojo C API for message pipes,
 // replacing the prefix of "Mojo" with a "mojo" namespace, and using more
 // strongly-typed representations of |MojoHandle|s.
 //
 // Please see "mojo/public/c/system/message_pipe.h" for complete documentation
 // of the API.
 
 #ifndef MOJO_PUBLIC_CPP_SYSTEM_MESSAGE_PIPE_H_
 #define MOJO_PUBLIC_CPP_SYSTEM_MESSAGE_PIPE_H_
 
-#include <assert.h>
 #include <stdint.h>
 
 #include "base/compiler_specific.h"
+#include "base/logging.h"
 #include "mojo/public/c/system/message_pipe.h"
 #include "mojo/public/cpp/system/handle.h"
 #include "mojo/public/cpp/system/macros.h"
 
 namespace mojo {
 
 // A strongly-typed representation of a |MojoHandle| to one end of a message
 // pipe.
 class MessagePipeHandle : public Handle {
  public:
   MessagePipeHandle() {}
   explicit MessagePipeHandle(MojoHandle value) : Handle(value) {}
 
   // Copying and assignment allowed.
 };
 
 static_assert(sizeof(MessagePipeHandle) == sizeof(Handle),
               "Bad size for C++ MessagePipeHandle");
 
 typedef ScopedHandleBase<MessagePipeHandle> ScopedMessagePipeHandle;
 static_assert(sizeof(ScopedMessagePipeHandle) == sizeof(MessagePipeHandle),
               "Bad size for C++ ScopedMessagePipeHandle");
 
 // Creates a message pipe. See |MojoCreateMessagePipe()| for complete
 // documentation.
 inline MojoResult CreateMessagePipe(const MojoCreateMessagePipeOptions* options,
                                     ScopedMessagePipeHandle* message_pipe0,
                                     ScopedMessagePipeHandle* message_pipe1) {
-  assert(message_pipe0);
-  assert(message_pipe1);
+  DCHECK(message_pipe0);
+  DCHECK(message_pipe1);
   MessagePipeHandle handle0;
   MessagePipeHandle handle1;
   MojoResult rv = MojoCreateMessagePipe(
       options, handle0.mutable_value(), handle1.mutable_value());
   // Reset even on failure (reduces the chances that a "stale"/incorrect handle
   // will be used).
   message_pipe0->reset(handle0);
   message_pipe1->reset(handle1);
   return rv;
 }
@@ skipping 37 matching lines @@
   MessagePipe();
   explicit MessagePipe(const MojoCreateMessagePipeOptions& options);
   ~MessagePipe();
 
   ScopedMessagePipeHandle handle0;
   ScopedMessagePipeHandle handle1;
 };
 
 inline MessagePipe::MessagePipe() {
   MojoResult result = CreateMessagePipe(nullptr, &handle0, &handle1);
-  ALLOW_UNUSED_LOCAL(result);
-  assert(result == MOJO_RESULT_OK);
+  DCHECK_EQ(MOJO_RESULT_OK, result);
 }
 
 inline MessagePipe::MessagePipe(const MojoCreateMessagePipeOptions& options) {
   MojoResult result = CreateMessagePipe(&options, &handle0, &handle1);
-  ALLOW_UNUSED_LOCAL(result);
-  assert(result == MOJO_RESULT_OK);
+  DCHECK_EQ(MOJO_RESULT_OK, result);
 }
 
 inline MessagePipe::~MessagePipe() {
 }
 
 }  // namespace mojo
 
 #endif  // MOJO_PUBLIC_CPP_SYSTEM_MESSAGE_PIPE_H_