Web MIDI: add a new UMA entry for the final result code

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"
 
 namespace media {
 namespace midi {
 
+namespace {
+const char kMidiResultOnShutdown[] = "Midi.ResultOnShutdown";
+};  // namespace
+
 MidiManager::MidiManager()
-    : initialized_(false),
-      result_(MIDI_NOT_SUPPORTED) {
+    : initialized_(false), result_(Result::NOT_SUPPORTED) {

[yhirano, 2015/07/07 07:05:21]

Perhaps not related with this cl, but should this be NOT_INITIALIZED?

[Takashi Toyoshima, 2015/07/09 05:02:54]

Oh, good catch. MidiManager set NOT_SUPPORTED in StartInitialization for
unsupported platforms, so this should be NOT_INITIALIZED.

 }
 
 MidiManager::~MidiManager() {
+  UMA_HISTOGRAM_ENUMERATION(kMidiResultOnShutdown, static_cast<int>(result_),
+                            static_cast<int>(Result::MAX));
 }
 
 #if !defined(OS_MACOSX) && !defined(OS_WIN) && \
     !(defined(USE_ALSA) && defined(USE_UDEV)) && !defined(OS_ANDROID)
 MidiManager* MidiManager::Create() {
   return new MidiManager;
 }
 #endif
 
 void MidiManager::StartSession(MidiManagerClient* client) {
@@ skipping 27 matching lines @@
   // Lazily initialize the MIDI back-end.
   if (!session_is_ready) {
     if (session_needs_initialization) {
       TRACE_EVENT0("midi", "MidiManager::StartInitialization");
       session_thread_runner_ =
           base::MessageLoop::current()->task_runner();
       StartInitialization();
     }
     if (too_many_pending_clients_exist) {
       // Return an error immediately if there are too many requests.
-      client->CompleteStartSession(MIDI_INITIALIZATION_ERROR);
+      client->CompleteStartSession(Result::INITIALIZATION_ERROR);
       return;
     }
     // CompleteInitialization() will be called asynchronously when platform
     // dependent initialization is finished.
     return;
   }
 
   // Platform dependent initialization was already finished for previously
   // initialized clients.
-  MidiResult result;
+  Result result;
   {
     base::AutoLock auto_lock(lock_);
-    if (result_ == MIDI_OK) {
+    if (result_ == Result::OK) {
       AddInitialPorts(client);
       clients_.insert(client);
     }
     result = result_;
   }
   client->CompleteStartSession(result);
 }
 
 void MidiManager::EndSession(MidiManagerClient* client) {
   // At this point, |client| can be in the destruction process, and calling
@@ skipping 13 matching lines @@
 }
 
 void MidiManager::DispatchSendMidiData(MidiManagerClient* client,
                                        uint32 port_index,
                                        const std::vector<uint8>& data,
                                        double timestamp) {
   NOTREACHED();
 }
 
 void MidiManager::StartInitialization() {
-  CompleteInitialization(MIDI_NOT_SUPPORTED);
+  CompleteInitialization(Result::NOT_SUPPORTED);
 }
 
-void MidiManager::CompleteInitialization(MidiResult result) {
+void MidiManager::CompleteInitialization(Result result) {
   DCHECK(session_thread_runner_.get());
   // It is safe to post a task to the IO thread from here because the IO thread
   // should have stopped if the MidiManager is going to be destructed.
   session_thread_runner_->PostTask(
       FROM_HERE,
       base::Bind(&MidiManager::CompleteInitializationInternal,
                  base::Unretained(this),
                  result));
 }
 
@@ skipping 31 matching lines @@
     uint32 port_index,
     const uint8* data,
     size_t length,
     double timestamp) {
   base::AutoLock auto_lock(lock_);
 
   for (auto client : clients_)
     client->ReceiveMidiData(port_index, data, length, timestamp);
 }
 
-void MidiManager::CompleteInitializationInternal(MidiResult result) {
+void MidiManager::CompleteInitializationInternal(Result result) {
   TRACE_EVENT0("midi", "MidiManager::CompleteInitialization");
 
   base::AutoLock auto_lock(lock_);
   DCHECK(clients_.empty());
   DCHECK(!initialized_);
   initialized_ = true;
   result_ = result;
 
   for (auto client : pending_clients_) {
-    if (result_ == MIDI_OK) {
+    if (result_ == Result::OK) {
       AddInitialPorts(client);
       clients_.insert(client);
     }
     client->CompleteStartSession(result_);
   }
   pending_clients_.clear();
 }
 
 void MidiManager::AddInitialPorts(MidiManagerClient* client) {
   lock_.AssertAcquired();
 
   for (const auto& info : input_ports_)
     client->AddInputPort(info);
   for (const auto& info : output_ports_)
     client->AddOutputPort(info);
 }
 
 }  // namespace midi
 }  // namespace media