Two fixes for mojo JS bindings

mojo/common/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/common/message_pump_mojo.h"
 
 #include <algorithm>
 #include <vector>
 
 #include "base/logging.h"
@@ skipping 136 matching lines @@
     uint32_t num_bytes = 0;
     ReadMessageRaw(run_state.read_handle.get(), NULL, &num_bytes, NULL, NULL,
                    MOJO_READ_MESSAGE_FLAG_MAY_DISCARD);
   } else if (result > 0) {
     const size_t index = static_cast<size_t>(result);
     DCHECK(handlers_.find(wait_state.handles[index]) != handlers_.end());
     handlers_[wait_state.handles[index]].handler->OnHandleReady(
         wait_state.handles[index]);
   } else {
     switch (result) {
+      case MOJO_RESULT_CANCELLED:
+      case MOJO_RESULT_FAILED_PRECONDITION:
       case MOJO_RESULT_INVALID_ARGUMENT:
-      case MOJO_RESULT_FAILED_PRECONDITION:
         RemoveFirstInvalidHandle(wait_state);
         break;
       case MOJO_RESULT_DEADLINE_EXCEEDED:
         break;
       default:
         NOTREACHED();

[darin (slow to review), 2014/05/09 22:00:15]

should this CHECK(false) so we learn if this ever happens in the field? you
might also use base::debug::Alias to ensure that |result| is available in crash
reports.

[sky, 2014/05/09 22:04:51]

Done.

     }
   }
 
   // Notify and remove any handlers whose time has expired. Make a copy in case
   // someone tries to add/remove new handlers from notification.
   const HandleToHandler cloned_handlers(handlers_);
   const base::TimeTicks now(internal::NowTicks());
   for (HandleToHandler::const_iterator i = cloned_handlers.begin();
        i != cloned_handlers.end(); ++i) {
     // Since we're iterating over a clone of the handlers, verify the handler is
     // still valid before notifying.
     if (!i->second.deadline.is_null() && i->second.deadline < now &&
         handlers_.find(i->first) != handlers_.end() &&
         handlers_[i->first].id == i->second.id) {
       i->second.handler->OnHandleError(i->first, MOJO_RESULT_DEADLINE_EXCEEDED);
     }
   }
 }
 
 void MessagePumpMojo::RemoveFirstInvalidHandle(const WaitState& wait_state) {
   // TODO(sky): deal with control pipe going bad.
   for (size_t i = 1; i < wait_state.handles.size(); ++i) {
     const MojoResult result =
         Wait(wait_state.handles[i], wait_state.wait_flags[i], 0);
     if (result == MOJO_RESULT_INVALID_ARGUMENT ||
-        result == MOJO_RESULT_FAILED_PRECONDITION) {
+        result == MOJO_RESULT_FAILED_PRECONDITION ||
+        result == MOJO_RESULT_CANCELLED) {
       // Remove the handle first, this way if OnHandleError() tries to remove
       // the handle our iterator isn't invalidated.
       DCHECK(handlers_.find(wait_state.handles[i]) != handlers_.end());
       MessagePumpMojoHandler* handler =
           handlers_[wait_state.handles[i]].handler;
       handlers_.erase(wait_state.handles[i]);
       handler->OnHandleError(wait_state.handles[i], result);
       return;
     }
   }
@@ skipping 28 matching lines @@
       min_time = i->second.deadline;
   }
   return min_time.is_null() ? MOJO_DEADLINE_INDEFINITE :
       std::max(static_cast<MojoDeadline>(0),
                static_cast<MojoDeadline>(
                    (min_time - internal::NowTicks()).InMicroseconds()));
 }
 
 }  // namespace common
 }  // namespace mojo