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

mojo/edk/system/data_pipe_producer_dispatcher.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/data_pipe_producer_dispatcher.h"
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/message_loop/message_loop.h"
 #include "mojo/edk/embedder/embedder_internal.h"
 #include "mojo/edk/embedder/platform_shared_buffer.h"
 #include "mojo/edk/embedder/platform_support.h"
 #include "mojo/edk/system/configuration.h"
 #include "mojo/edk/system/data_pipe.h"
 
 namespace mojo {
 namespace edk {
 
 void DataPipeProducerDispatcher::Init(
     ScopedPlatformHandle message_pipe,
     char* serialized_write_buffer, size_t serialized_write_buffer_size) {
   if (message_pipe.is_valid()) {
     channel_ = RawChannel::Create(message_pipe.Pass());
     channel_->SetSerializedData(
         nullptr, 0u, serialized_write_buffer, serialized_write_buffer_size);
     internal::g_io_thread_task_runner->PostTask(
         FROM_HERE, base::Bind(&DataPipeProducerDispatcher::InitOnIO, this));
+  } else {
+    error_ = true;
   }
 }
 
 void DataPipeProducerDispatcher::InitOnIO() {
   base::AutoLock locker(lock());
   if (channel_)
     channel_->Init(this);
 }
 
 void DataPipeProducerDispatcher::CloseOnIO() {
@@ skipping 27 matching lines @@
   scoped_refptr<PlatformSharedBuffer> shared_buffer;
   scoped_ptr<PlatformSharedBufferMapping> mapping;
   if (shared_memory_size) {
     shared_buffer = internal::g_platform_support->CreateSharedBufferFromHandle(
         shared_memory_size, shared_memory_handle.Pass());
     mapping = shared_buffer->Map(0, shared_memory_size);
     serialized_write_buffer = static_cast<char*>(mapping->GetBase());
     serialized_write_buffer_size = shared_memory_size;
   }
 
-  if (platform_handle.is_valid()) {
-    rv->Init(platform_handle.Pass(), serialized_write_buffer,
-             serialized_write_buffer_size);
-  }
+  rv->Init(platform_handle.Pass(), serialized_write_buffer,
+           serialized_write_buffer_size);
   return rv;
 }
 
 DataPipeProducerDispatcher::DataPipeProducerDispatcher(
     const MojoCreateDataPipeOptions& options)
     : options_(options), channel_(nullptr), error_(false) {
 }
 
 DataPipeProducerDispatcher::~DataPipeProducerDispatcher() {
   // |Close()|/|CloseImplNoLock()| should have taken care of the channel.
@@ skipping 238 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) << "DataPipeProducerDispatcher 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 26 matching lines @@
     }
 
     offset += message_num_bytes;
   }
 
   return true;
 }
 
 }  // namespace edk
 }  // namespace mojo