Couple of small cleanups to MessagePumpMojo.

mojo/message_pump/message_pump_mojo.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/message_pump/message_pump_mojo.h"
 
 #include <stdint.h>
 
 #include <algorithm>
 #include <map>
@@ skipping 277 matching lines @@
       case MOJO_RESULT_CANCELLED:
       case MOJO_RESULT_FAILED_PRECONDITION:
         DVLOG(1) << "Error: " << handle_results[i]
                  << " handle: " << handle.value();
         if (handle.value() == read_handle_.get().value()) {
           // The Mojo EDK is shutting down. The ThreadQuitHelper task in
           // base::Thread won't get run since the control pipe depends on the
           // EDK staying alive. So quit manually to avoid this thread hanging.
           Quit();
         } else {
-          RemoveInvalidHandle(handle_results[i], handle);
+          SignalHandleError(handle, handle_results[i]);
         }
         break;
       case MOJO_RESULT_OK:
         if (handle.value() == read_handle_.get().value()) {
           DVLOG(1) << "Signaled control pipe";
           // Control pipe was written to.
           ReadMessageRaw(read_handle_.get(), nullptr, nullptr, nullptr, nullptr,
                          MOJO_READ_MESSAGE_FLAG_MAY_DISCARD);
         } else {
           DVLOG(1) << "Handle ready: " << handle.value();
           SignalHandleReady(handle);
         }
         break;
       default:
         base::debug::Alias(&i);
         base::debug::Alias(&handle_results[i]);
         // Unexpected result is likely fatal, crash so we can determine cause.
         CHECK(false);
     }
   }
   return true;
 }
 
-void MessagePumpMojo::RemoveInvalidHandle(MojoResult result, Handle handle) {
-  // TODO(sky): deal with control pipe going bad.
-  CHECK(result == MOJO_RESULT_FAILED_PRECONDITION ||
-        result == MOJO_RESULT_CANCELLED ||
-        result == MOJO_RESULT_DEADLINE_EXCEEDED);
-  // Indicates the control pipe went bad.
-  CHECK_NE(handle.value(), read_handle_.get().value());
-
-  auto it = handlers_.find(handle);
-  CHECK(it != handlers_.end());
-  MessagePumpMojoHandler* handler = it->second.handler;
-  RemoveHandler(handle);
-  WillSignalHandler();
-  handler->OnHandleError(handle, result);
-  DidSignalHandler();
-}
-
 bool MessagePumpMojo::RemoveExpiredHandles() {
   bool removed = false;
   // Notify and remove any handlers whose time has expired. First, iterate over
   // the set of handles that have a deadline, and add the expired handles to a
   // map of <Handle, id>. Then, iterate over those expired handles and remove
   // them. The two-step process is because a handler can add/remove new
   // handlers.
   std::map<Handle, int> expired_handles;
   const base::TimeTicks now(internal::NowTicks());
   for (const Handle handle : deadline_handles_) {
     const auto it = handlers_.find(handle);
     // Expect any handle in |deadline_handles_| to also be in |handlers_| since
     // the two are modified in lock-step.
     DCHECK(it != handlers_.end());
     if (!it->second.deadline.is_null() && it->second.deadline < now)
       expired_handles[handle] = it->second.id;
   }
   for (const auto& pair : expired_handles) {
     auto it = handlers_.find(pair.first);
     // Don't need to check deadline again since it can't change if id hasn't
     // changed.
     if (it != handlers_.end() && it->second.id == pair.second) {
-      MessagePumpMojoHandler* handler = it->second.handler;
-      RemoveHandler(pair.first);
-      WillSignalHandler();
-      handler->OnHandleError(pair.first, MOJO_RESULT_DEADLINE_EXCEEDED);
-      DidSignalHandler();
+      SignalHandleError(pair.first, MOJO_RESULT_DEADLINE_EXCEEDED);
       removed = true;
     }
   }
   return removed;
 }
 
 void MessagePumpMojo::SignalControlPipe() {
   const MojoResult result =
       WriteMessageRaw(write_handle_.get(), NULL, 0, NULL, 0,
                       MOJO_WRITE_MESSAGE_FLAG_NONE);
@@ skipping 15 matching lines @@
   for (const Handle handle : deadline_handles_) {
     auto it = handlers_.find(handle);
     DCHECK(it != handlers_.end());
     deadline = std::min(
         TimeTicksToMojoDeadline(it->second.deadline, now), deadline);
   }
   return deadline;
 }
 
 void MessagePumpMojo::SignalHandleReady(Handle handle) {
-  DCHECK(handlers_.find(handle) != handlers_.end());
+  auto it = handlers_.find(handle);
+  DCHECK(it != handlers_.end());
+  MessagePumpMojoHandler* handler = it->second.handler;
+
   WillSignalHandler();
-  handlers_[handle].handler->OnHandleReady(handle);
+  handler->OnHandleReady(handle);
   DidSignalHandler();
 }
 
+void MessagePumpMojo::SignalHandleError(Handle handle, MojoResult result) {
+  auto it = handlers_.find(handle);
+  DCHECK(it != handlers_.end());
+  MessagePumpMojoHandler* handler = it->second.handler;
+
+  RemoveHandler(handle);
+  WillSignalHandler();
+  handler->OnHandleError(handle, result);
+  DidSignalHandler();
+}
+
 void MessagePumpMojo::WillSignalHandler() {
   FOR_EACH_OBSERVER(Observer, observers_, WillSignalHandler());
 }
 
 void MessagePumpMojo::DidSignalHandler() {
   FOR_EACH_OBSERVER(Observer, observers_, DidSignalHandler());
 }
 
 }  // namespace common
 }  // namespace mojo