Web MIDI: introduce MidiManager::Shutdown to shutdown gracefully

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 25 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()
-    : initialized_(false), result_(Result::NOT_INITIALIZED) {
+    : initialized_(false),
+      shutted_down_(false),
+      result_(Result::NOT_INITIALIZED) {
   ReportUsage(Usage::CREATED);
 }
 
 MidiManager::~MidiManager() {
-  UMA_HISTOGRAM_ENUMERATION("Media.Midi.ResultOnShutdown",
-                            static_cast<Sample>(result_),
-                            static_cast<Sample>(Result::MAX) + 1);
+  // Make sure that Shutdown() is called to clean up resources allocated on
+  // the Chrome_IOThread.
+  DCHECK(shutted_down_);

[yhirano, 2015/09/07 06:00:25]

Shouldn't we check that it is correctly finalized?
I'm not sure who ensures the condition, though.

[Takashi Toyoshima, 2015/09/07 19:04:39]

We can do nothing here to recover even if Shutdown() fails. So, I think making
Shutdown returning boolean result and checking it here does not make sense.
It would be easy and reasonable to add DCHECK directly for each operation in
Shutdown().

On the other hand, this shutdown check is useful to write unit tests correctly.

[yhirano, 2015/09/08 04:59:37]

What I'm worrying about is the case where the posted Finalize runs (on the IO
thread) after the MidiManager is destructed (on the main loop thread). Are you
sure there is no such case?

 }
 
 #if !defined(OS_MACOSX) && !defined(OS_WIN) && \
     !(defined(USE_ALSA) && defined(USE_UDEV)) && !defined(OS_ANDROID)
 MidiManager* MidiManager::Create() {
   ReportUsage(Usage::CREATED_ON_UNSUPPORTED_PLATFORMS);
   return new MidiManager;
 }
 #endif
 
+void MidiManager::Shutdown() {
+  shutted_down_ = true;
+  UMA_HISTOGRAM_ENUMERATION("Media.Midi.ResultOnShutdown",
+                            static_cast<int>(result_),
+                            static_cast<int>(Result::MAX) + 1);
+  if (session_thread_runner_) {
+    session_thread_runner_->PostTask(
+        FROM_HERE, base::Bind(&MidiManager::Finalize, base::Unretained(this)));
+  }
+}
+
 void MidiManager::StartSession(MidiManagerClient* client) {
   ReportUsage(Usage::SESSION_STARTED);
 
   bool session_is_ready;
   bool session_needs_initialization = false;
   bool too_many_pending_clients_exist = false;
 
   {
     base::AutoLock auto_lock(lock_);
     session_is_ready = initialized_;
@@ skipping 163 matching lines @@
   lock_.AssertAcquired();
 
   for (const auto& info : input_ports_)
     client->AddInputPort(info);
   for (const auto& info : output_ports_)
     client->AddOutputPort(info);
 }
 
 }  // namespace midi
 }  // namespace media