IPC->mojo of audio_renderer_host

mojo/edk/system/core.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/edk/system/core.h"
 
 #include <string.h>
 
 #include <utility>
 
@@ skipping 455 matching lines @@
   if (!dispatcher)
     return MOJO_RESULT_INVALID_ARGUMENT;
   return dispatcher->CancelWatch(context);
 }
 
 MojoResult Core::AllocMessage(uint32_t num_bytes,
                               const MojoHandle* handles,
                               uint32_t num_handles,
                               MojoAllocMessageFlags flags,
                               MojoMessageHandle* message) {
-  if (!message)
-    return MOJO_RESULT_INVALID_ARGUMENT;
+  DCHECK(message);
 
   if (num_handles == 0) {  // Fast path: no handles.
     std::unique_ptr<MessageForTransit> msg;
     MojoResult rv = MessageForTransit::Create(&msg, num_bytes, nullptr, 0);
-    if (rv != MOJO_RESULT_OK)
-      return rv;
+    DCHECK(rv == MOJO_RESULT_OK) << rv;
 
     *message = reinterpret_cast<MojoMessageHandle>(msg.release());
     return MOJO_RESULT_OK;
   }
 
-  if (!handles)
-    return MOJO_RESULT_INVALID_ARGUMENT;
+  DCHECK(handles);
 
   if (num_handles > kMaxHandlesPerMessage)
     return MOJO_RESULT_RESOURCE_EXHAUSTED;
 
   std::vector<Dispatcher::DispatcherInTransit> dispatchers;
   {
     base::AutoLock lock(handles_lock_);
     MojoResult rv = handles_.BeginTransit(handles, num_handles, &dispatchers);
-    if (rv != MOJO_RESULT_OK) {
-      handles_.CancelTransit(dispatchers);
-      return rv;
-    }
+    DCHECK(rv == MOJO_RESULT_OK) << rv;
   }
   DCHECK_EQ(num_handles, dispatchers.size());
 
   std::unique_ptr<MessageForTransit> msg;
   MojoResult rv = MessageForTransit::Create(
       &msg, num_bytes, dispatchers.data(), num_handles);
 
   {
     base::AutoLock lock(handles_lock_);
     if (rv == MOJO_RESULT_OK) {
       handles_.CompleteTransitAndClose(dispatchers);
       *message = reinterpret_cast<MojoMessageHandle>(msg.release());
     } else {
       handles_.CancelTransit(dispatchers);
     }
   }
 
+  DCHECK(rv == MOJO_RESULT_OK) << rv;
   return rv;
 }
 
 MojoResult Core::FreeMessage(MojoMessageHandle message) {
   if (!message)
     return MOJO_RESULT_INVALID_ARGUMENT;
 
   delete reinterpret_cast<MessageForTransit*>(message);
 
   return MOJO_RESULT_OK;
@@ skipping 660 matching lines @@
     std::unique_ptr<NodeController> node_controller) {
   // It's OK to leak this reference. At this point we know the IO loop is still
   // running, and we know the NodeController will observe its eventual
   // destruction. This tells the NodeController to delete itself when that
   // happens.
   node_controller.release()->DestroyOnIOThreadShutdown();
 }
 
 }  // namespace edk
 }  // namespace mojo