Revert of Remove MessageLoop destruction observer from mojo::Watcher.

ipc/ipc_sync_channel.cc

 // Copyright (c) 2012 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 "ipc/ipc_sync_channel.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <utility>
@@ skipping 27 matching lines @@
 // to true. Also sets |*error| to true in case of an error.
 void OnSyncHandleReady(bool* signal, bool* error, MojoResult result) {
   *signal = true;
   *error = result != MOJO_RESULT_OK;
 }
 
 // A ReadyCallback for use with mojo::Watcher. Ignores the result (DCHECKs, but
 // is only used in cases where failure should be impossible) and runs
 // |callback|.
 void RunOnHandleReady(const base::Closure& callback, MojoResult result) {
-  DCHECK_EQ(result, MOJO_RESULT_OK);
-  callback.Run();
+  DCHECK(result == MOJO_RESULT_OK || result == MOJO_RESULT_ABORTED);
+  if (result == MOJO_RESULT_OK)
+    callback.Run();
 }
 
 class PumpMessagesEvent {
  public:
   PumpMessagesEvent() { event_.Signal(); }
   ~PumpMessagesEvent() {}
 
   const MojoEvent* event() const { return &event_; }
 
  private:
@@ skipping 611 matching lines @@
     nested_loop.Run();
     send_done_watcher.Cancel();
   }
 
   sync_msg_queue->set_top_send_done_watcher(old_watcher);
   if (old_watcher)
     old_watcher->Start(old_handle, MOJO_HANDLE_SIGNAL_READABLE, old_callback);
 }
 
 void SyncChannel::OnDispatchHandleReady(MojoResult result) {
-  DCHECK_EQ(result, MOJO_RESULT_OK);
-  sync_context()->GetDispatchEvent()->Reset();
-  sync_context()->DispatchMessages();
+  DCHECK(result == MOJO_RESULT_OK || result == MOJO_RESULT_ABORTED);
+  if (result == MOJO_RESULT_OK) {
+    sync_context()->GetDispatchEvent()->Reset();
+    sync_context()->DispatchMessages();
+  }
 }
 
 void SyncChannel::StartWatching() {
   // |dispatch_watcher_| watches the event asynchronously, only dispatching
   // messages once the listener thread is unblocked and pumping its task queue.
   // The ReceivedSyncMsgQueue also watches this event and may dispatch
   // immediately if woken up by a message which it's allowed to dispatch.
   dispatch_watcher_.Start(sync_context()->GetDispatchEvent()->GetHandle(),
                           MOJO_HANDLE_SIGNAL_READABLE,
                           base::Bind(&SyncChannel::OnDispatchHandleReady,
                                      base::Unretained(this)));
 }
 
 void SyncChannel::OnChannelInit() {
   pre_init_sync_message_filters_.clear();
 }
 
 }  // namespace IPC