Remove RawChannel::Init() and Channel::Init() failure cases.

mojo/edk/system/raw_channel.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/raw_channel.h"
 
 #include <string.h>
 
 #include <algorithm>
 
@@ skipping 153 matching lines @@
 RawChannel::~RawChannel() {
   DCHECK(!read_buffer_);
   DCHECK(!write_buffer_);
 
   // No need to take the |write_lock_| here -- if there are still weak pointers
   // outstanding, then we're hosed anyway (since we wouldn't be able to
   // invalidate them cleanly, since we might not be on the I/O thread).
   DCHECK(!weak_ptr_factory_.HasWeakPtrs());
 }
 
-bool RawChannel::Init(Delegate* delegate) {
+void RawChannel::Init(Delegate* delegate) {
   DCHECK(delegate);
 
   DCHECK(!delegate_);
   delegate_ = delegate;
 
   CHECK_EQ(base::MessageLoop::current()->type(), base::MessageLoop::TYPE_IO);
   DCHECK(!message_loop_for_io_);
   message_loop_for_io_ =
       static_cast<base::MessageLoopForIO*>(base::MessageLoop::current());
 
   // No need to take the lock. No one should be using us yet.
   DCHECK(!read_buffer_);
   read_buffer_.reset(new ReadBuffer);
   DCHECK(!write_buffer_);
   write_buffer_.reset(new WriteBuffer(GetSerializedPlatformHandleSize()));
 
-  if (!OnInit()) {
-    delegate_ = nullptr;
-    message_loop_for_io_ = nullptr;
-    read_buffer_.reset();
-    write_buffer_.reset();
-    return false;
-  }
+  OnInit();
 
   IOResult io_result = ScheduleRead();
   if (io_result != IO_PENDING) {
     // This will notify the delegate about the read failure. Although we're on
     // the I/O thread, don't call it in the nested context.
     message_loop_for_io_->PostTask(
         FROM_HERE, base::Bind(&RawChannel::OnReadCompleted,
                               weak_ptr_factory_.GetWeakPtr(), io_result, 0));
   }
-
-  // ScheduleRead() failure is treated as a read failure (by notifying the
-  // delegate), not as an init failure.
-  return true;
+  // Note: |ScheduleRead()| failure is treated as a read failure (by notifying
+  // the delegate), not an initialization failure.
 }
 
 void RawChannel::Shutdown() {
   DCHECK_EQ(base::MessageLoop::current(), message_loop_for_io_);
 
   base::AutoLock locker(write_lock_);
 
   LOG_IF(WARNING, !write_buffer_->message_queue_.empty())
       << "Shutting down RawChannel with write buffer nonempty";
 
@@ skipping 292 matching lines @@
 
   write_stopped_ = true;
   STLDeleteElements(&write_buffer_->message_queue_);
   write_buffer_->platform_handles_offset_ = 0;
   write_buffer_->data_offset_ = 0;
   return false;
 }
 
 }  // namespace system
 }  // namespace mojo