Fix some MultiplexRouter behavior for sync messages

mojo/public/cpp/bindings/lib/multiplex_router.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/public/cpp/bindings/lib/multiplex_router.h"
 
 #include <stdint.h>
 
 #include <utility>
 
@@ skipping 576 matching lines @@
     return;
 
   while (!tasks_.empty()) {
     std::unique_ptr<Task> task(std::move(tasks_.front()));
     tasks_.pop_front();
 
     InterfaceId id = kInvalidInterfaceId;
     bool sync_message = task->IsMessageTask() && task->message &&
                         task->message->has_flag(kMessageIsSync);
     if (sync_message) {
-      InterfaceId id = task->message->interface_id();
+      id = task->message->interface_id();
       auto& sync_message_queue = sync_message_tasks_[id];
       DCHECK_EQ(task.get(), sync_message_queue.front());
       sync_message_queue.pop_front();
     }
 
     bool processed =
         task->IsNotifyErrorTask()
             ? ProcessNotifyErrorTask(task.get(), client_call_behavior,
                                      current_task_runner)
             : ProcessIncomingMessage(task->message.get(), client_call_behavior,
                                      current_task_runner);
 
     if (!processed) {
-      tasks_.push_front(std::move(task));
       if (sync_message) {
         auto& sync_message_queue = sync_message_tasks_[id];
         sync_message_queue.push_front(task.get());
       }
+      tasks_.push_front(std::move(task));
       break;
     } else {
       if (sync_message) {
         auto iter = sync_message_tasks_.find(id);
         if (iter != sync_message_tasks_.end() && iter->second.empty())
           sync_message_tasks_.erase(iter);
       }
     }
   }
 }
@@ skipping 10 matching lines @@
 
   DCHECK(task->IsMessageTask());
   std::unique_ptr<Message> message(std::move(task->message));
 
   // Note: after this call, |task| and  |iter| may be invalidated.
   bool processed = ProcessIncomingMessage(
       message.get(), ALLOW_DIRECT_CLIENT_CALLS_FOR_SYNC_MESSAGES, nullptr);
   DCHECK(processed);
 
   iter = sync_message_tasks_.find(id);
-  return iter != sync_message_tasks_.end() && !iter->second.empty();
+  if (iter == sync_message_tasks_.end())
+    return false;
+
+  if (iter->second.empty()) {
+    sync_message_tasks_.erase(iter);
+    return false;
+  }
+
+  return true;
 }
 
 bool MultiplexRouter::ProcessNotifyErrorTask(
     Task* task,
     ClientCallBehavior client_call_behavior,
     base::SingleThreadTaskRunner* current_task_runner) {
   DCHECK(!current_task_runner || current_task_runner->BelongsToCurrentThread());
   lock_.AssertAcquired();
   InterfaceEndpoint* endpoint = task->endpoint_to_notify.get();
   if (!endpoint->client())
@@ skipping 164 matching lines @@
       *inserted = true;
   } else {
     endpoint = iter->second.get();
   }
 
   return endpoint;
 }
 
 }  // namespace internal
 }  // namespace mojo