Web MIDI: add dynamic MidiManager instantiation support for Linux

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/location.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/single_thread_task_runner.h"
@@ skipping 28 matching lines @@
 };
 
 void ReportUsage(Usage usage) {
   UMA_HISTOGRAM_ENUMERATION("Media.Midi.Usage",
                             static_cast<Sample>(usage),
                             static_cast<Sample>(Usage::MAX) + 1);
 }
 
 }  // namespace
 
-MidiManager::MidiManager()
+MidiManager::MidiManager(MidiService* service)
     : initialization_state_(InitializationState::NOT_STARTED),
       finalized_(false),
-      result_(Result::NOT_INITIALIZED) {
+      result_(Result::NOT_INITIALIZED),
+      service_(service) {
   ReportUsage(Usage::CREATED);
 }
 
 MidiManager::~MidiManager() {
   // Make sure that Finalize() is called to clean up resources allocated on
   // the Chrome_IOThread.
   base::AutoLock auto_lock(lock_);
   CHECK(finalized_);
 }
 
 #if !defined(OS_MACOSX) && !defined(OS_WIN) && \
     !(defined(USE_ALSA) && defined(USE_UDEV)) && !defined(OS_ANDROID)
-MidiManager* MidiManager::Create() {
+MidiManager* MidiManager::Create(MidiService* service) {
   ReportUsage(Usage::CREATED_ON_UNSUPPORTED_PLATFORMS);
-  return new MidiManager;
+  return new MidiManager(service);
 }
 #endif
 
 void MidiManager::Shutdown() {
   UMA_HISTOGRAM_ENUMERATION("Media.Midi.ResultOnShutdown",
                             static_cast<int>(result_),
                             static_cast<int>(Result::MAX) + 1);
-  base::AutoLock auto_lock(lock_);
-  if (session_thread_runner_) {
-    session_thread_runner_->PostTask(
-        FROM_HERE, base::Bind(&MidiManager::ShutdownOnSessionThread,
-                              base::Unretained(this)));
-    session_thread_runner_ = nullptr;
-  } else {
-    finalized_ = true;
+  bool shutdown_synchronously = false;
+  {
+    base::AutoLock auto_lock(lock_);
+    if (session_thread_runner_) {
+      if (session_thread_runner_->BelongsToCurrentThread()) {
+        shutdown_synchronously = true;
+      } else {
+        session_thread_runner_->PostTask(
+            FROM_HERE, base::Bind(&MidiManager::ShutdownOnSessionThread,
+                                  base::Unretained(this)));
+      }
+      session_thread_runner_ = nullptr;
+    } else {
+      finalized_ = true;
+    }
   }
+  if (shutdown_synchronously)
+    ShutdownOnSessionThread();
 }
 
 void MidiManager::StartSession(MidiManagerClient* client) {
   ReportUsage(Usage::SESSION_STARTED);
 
   bool needs_initialization = false;
 
   {
     base::AutoLock auto_lock(lock_);
     if (clients_.find(client) != clients_.end() ||
@@ skipping 170 matching lines @@
   Finalize();
   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