Prevent a race condition with MidiHost IPC sending.

media/midi/midi_manager.cc

 // Copyright (c) 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 "media/midi/midi_manager.h"
 
 #include "base/bind.h"
 #include "base/message_loop/message_loop.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/trace_event/trace_event.h"
@@ skipping 108 matching lines @@
         // Call StartInitialization() only for the first request.
         if (pending_clients_.empty()) {
           completion = Completion::INVOKE_INITIALIZATION;
           session_thread_runner_ = base::MessageLoop::current()->task_runner();
         } else {
           completion = Completion::COMPLETE_ASYNCHRONOUSLY;
         }
         pending_clients_.insert(client);
       }
     }
+
+    if (completion == Completion::COMPLETE_SYNCHRONOUSLY) {
+      client->CompleteStartSession(result);
+      return;
+    }
   }
 
-  if (completion == Completion::COMPLETE_SYNCHRONOUSLY) {
-    client->CompleteStartSession(result);
-  } else if (completion == Completion::INVOKE_INITIALIZATION) {
+  if (completion == Completion::INVOKE_INITIALIZATION) {
     // Lazily initialize the MIDI back-end.
     TRACE_EVENT0("midi", "MidiManager::StartInitialization");
     // CompleteInitialization() will be called asynchronously when platform
     // dependent initialization is finished.
     StartInitialization();
   }
 }
 
 void MidiManager::EndSession(MidiManagerClient* client) {
   ReportUsage(Usage::SESSION_ENDED);
 
   // At this point, |client| can be in the destruction process, and calling
-  // any method of |client| is dangerous.
+  // any method of |client| is dangerous. Calls on clients *must* be protected
+  // by |lock_| to prevent race conditions.
   base::AutoLock auto_lock(lock_);
   clients_.erase(client);
   pending_clients_.erase(client);
 }
 
 void MidiManager::AccumulateMidiBytesSent(MidiManagerClient* client, size_t n) {
   base::AutoLock auto_lock(lock_);
   if (clients_.find(client) == clients_.end())
     return;
 
   // Continue to hold lock_ here in case another thread is currently doing
   // EndSession.
-  // Note that if we are in EndSession, then a destructor is being called and
-  // it isn't really safe to call this method. But we don't have another way to
-  // check this right now.
   client->AccumulateMidiBytesSent(n);
 }
 
 void MidiManager::DispatchSendMidiData(MidiManagerClient* client,
                                        uint32_t port_index,
                                        const std::vector<uint8_t>& data,
                                        double timestamp) {
   NOTREACHED();
 }
 
@@ skipping 92 matching lines @@
   base::AutoLock auto_lock(lock_);
   finalized_ = true;
 
   // Detach all clients so that they do not call MidiManager methods any more.
   for (auto client : clients_)
     client->Detach();
 }
 
 }  // namespace midi
 }  // namespace media