Last set of fixes to make the src/mojo/edk pass the page cycler.

mojo/edk/system/message_pipe_dispatcher.cc

 // Copyright 2015 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/message_pipe_dispatcher.h"
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/message_loop/message_loop.h"
 #include "mojo/edk/embedder/embedder_internal.h"
@@ skipping 100 matching lines @@
     channel_->SetSerializedData(
         serialized_read_buffer, serialized_read_buffer_size,
         serialized_write_buffer, serialized_write_buffer_size);
     if (g_use_channel_on_io_thread_only) {
       internal::g_io_thread_task_runner->PostTask(
           FROM_HERE, base::Bind(&MessagePipeDispatcher::InitOnIO, this));
     } else {
       InitOnIO();
     }
     // TODO(jam): optimize for when running on IO thread?
+  } else {
+    error_ = true;
   }
 }
 
 void MessagePipeDispatcher::InitOnIO() {
   base::AutoLock locker(lock());
   calling_init_ = true;
   if (channel_)
     channel_->Init(this);
   calling_init_ = false;
 }
@@ skipping 498 matching lines @@
             serialization->shared_memory_size));
     scoped_ptr<PlatformSharedBufferMapping> mapping(
         shared_buffer->Map(0, serialization->shared_memory_size));
     char* start = static_cast<char*>(mapping->GetBase());
     start = SerializeBuffer(start, &serialized_read_buffer_);
     start = SerializeBuffer(start, &serialized_write_buffer_);
     start = SerializeBuffer(start, &serialized_message_queue_);
 
     serialization->shared_memory_handle_index = platform_handles->size();
     platform_handles->push_back(shared_buffer->PassPlatformHandle().release());
+  } else {
+    serialization->shared_memory_handle_index = kInvalidMessagePipeHandleIndex;
   }
 
   *actual_size = sizeof(SerializedMessagePipeHandleDispatcher);
   return true;
 }
 
 void MessagePipeDispatcher::TransportStarted() {
   started_transport_.Acquire();
 }
 
@@ skipping 65 matching lines @@
     case ERROR_WRITE:
       // Write errors are slightly notable: they probably shouldn't happen under
       // normal operation (but maybe the other side crashed).
       LOG(WARNING) << "MessagePipeDispatcher write error";
       break;
   }
 
   error_ = true;
   if (started_transport_.Try()) {
     base::AutoLock locker(lock());
+    // We can get two OnError callbacks before the post task below completes.
+    // Although RawChannel still has a pointer to this object until Shutdown is
+    // called, that is safe since this class always does a PostTask to the IO
+    // thread to self destruct.
+    if (!channel_)
+      return;
+
     awakable_list_.AwakeForStateChange(GetHandleSignalsStateImplNoLock());
 
     base::MessageLoop::current()->PostTask(
         FROM_HERE,
         base::Bind(&RawChannel::Shutdown, base::Unretained(channel_)));
     channel_ = nullptr;
     started_transport_.Release();
   } else {
     // We must be waiting to call ReleaseHandle. It will call Shutdown.
   }
@@ skipping 37 matching lines @@
       LOG(WARNING) << "Enqueueing null dispatcher";
       dispatchers->push_back(nullptr);
     }
   }
   message->SetDispatchers(dispatchers.Pass());
   return MOJO_RESULT_OK;
 }
 
 }  // namespace edk
 }  // namespace mojo