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

media/midi/midi_manager_alsa.cc

 // Copyright 2014 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_alsa.h"
 
 #include <poll.h>
 #include <stdlib.h>
 #include <algorithm>
 #include <string>
@@ skipping 167 matching lines @@
 
 void MidiManagerAlsa::StartInitialization() {
   // TODO(agoode): Move off I/O thread. See http://crbug.com/374341.
 
   // Create client handles.
   snd_seq_t* in_client;
   int err =
       snd_seq_open(&in_client, kAlsaHw, SND_SEQ_OPEN_INPUT, SND_SEQ_NONBLOCK);
   if (err != 0) {
     VLOG(1) << "snd_seq_open fails: " << snd_strerror(err);
-    return CompleteInitialization(MIDI_INITIALIZATION_ERROR);
+    return CompleteInitialization(Result::INITIALIZATION_ERROR);
   }
   in_client_.reset(in_client);
   in_client_id_ = snd_seq_client_id(in_client_.get());
 
   snd_seq_t* out_client;
   err = snd_seq_open(&out_client, kAlsaHw, SND_SEQ_OPEN_OUTPUT, 0);
   if (err != 0) {
     VLOG(1) << "snd_seq_open fails: " << snd_strerror(err);
-    return CompleteInitialization(MIDI_INITIALIZATION_ERROR);
+    return CompleteInitialization(Result::INITIALIZATION_ERROR);
   }
   out_client_.reset(out_client);
   out_client_id_ = snd_seq_client_id(out_client_.get());
 
   // Name the clients.
   err = snd_seq_set_client_name(in_client_.get(), "Chrome (input)");
   if (err != 0) {
     VLOG(1) << "snd_seq_set_client_name fails: " << snd_strerror(err);
-    return CompleteInitialization(MIDI_INITIALIZATION_ERROR);
+    return CompleteInitialization(Result::INITIALIZATION_ERROR);
   }
   err = snd_seq_set_client_name(out_client_.get(), "Chrome (output)");
   if (err != 0) {
     VLOG(1) << "snd_seq_set_client_name fails: " << snd_strerror(err);
-    return CompleteInitialization(MIDI_INITIALIZATION_ERROR);
+    return CompleteInitialization(Result::INITIALIZATION_ERROR);
   }
 
   // Create input port.
   in_port_id_ = snd_seq_create_simple_port(
       in_client_.get(), NULL, kCreateInputPortCaps, kCreatePortType);
   if (in_port_id_ < 0) {
     VLOG(1) << "snd_seq_create_simple_port fails: "
             << snd_strerror(in_port_id_);
-    return CompleteInitialization(MIDI_INITIALIZATION_ERROR);
+    return CompleteInitialization(Result::INITIALIZATION_ERROR);
   }
 
   // Subscribe to the announce port.
   snd_seq_port_subscribe_t* subs;
   snd_seq_port_subscribe_alloca(&subs);
   snd_seq_addr_t announce_sender;
   snd_seq_addr_t announce_dest;
   announce_sender.client = SND_SEQ_CLIENT_SYSTEM;
   announce_sender.port = SND_SEQ_PORT_SYSTEM_ANNOUNCE;
   announce_dest.client = in_client_id_;
   announce_dest.port = in_port_id_;
   snd_seq_port_subscribe_set_sender(subs, &announce_sender);
   snd_seq_port_subscribe_set_dest(subs, &announce_dest);
   err = snd_seq_subscribe_port(in_client_.get(), subs);
   if (err != 0) {
     VLOG(1) << "snd_seq_subscribe_port on the announce port fails: "
             << snd_strerror(err);
-    return CompleteInitialization(MIDI_INITIALIZATION_ERROR);
+    return CompleteInitialization(Result::INITIALIZATION_ERROR);
   }
 
   // Generate hotplug events for existing ports.
   // TODO(agoode): Check the return value for failure.
   EnumerateAlsaPorts();
 
   // Initialize udev monitor.
   udev_monitor_.reset(
       device::udev_monitor_new_from_netlink(udev_.get(), kUdev));
   if (!udev_monitor_.get()) {
     VLOG(1) << "udev_monitor_new_from_netlink fails";
-    return CompleteInitialization(MIDI_INITIALIZATION_ERROR);
+    return CompleteInitialization(Result::INITIALIZATION_ERROR);
   }
   err = device::udev_monitor_filter_add_match_subsystem_devtype(
       udev_monitor_.get(), kUdevSubsystemSound, nullptr);
   if (err != 0) {
     VLOG(1) << "udev_monitor_add_match_subsystem fails: "
             << base::safe_strerror(-err);
-    return CompleteInitialization(MIDI_INITIALIZATION_ERROR);
+    return CompleteInitialization(Result::INITIALIZATION_ERROR);
   }
   err = device::udev_monitor_enable_receiving(udev_monitor_.get());
   if (err != 0) {
     VLOG(1) << "udev_monitor_enable_receiving fails: "
             << base::safe_strerror(-err);
-    return CompleteInitialization(MIDI_INITIALIZATION_ERROR);
+    return CompleteInitialization(Result::INITIALIZATION_ERROR);
   }
 
   // Generate hotplug events for existing udev devices.
   EnumerateUdevCards();
 
   // Start processing events.
   event_thread_.Start();
   event_thread_.message_loop()->PostTask(
       FROM_HERE,
       base::Bind(&MidiManagerAlsa::ScheduleEventLoop, base::Unretained(this)));
 
-  CompleteInitialization(MIDI_OK);
+  CompleteInitialization(Result::OK);
 }
 
 void MidiManagerAlsa::DispatchSendMidiData(MidiManagerClient* client,
                                            uint32 port_index,
                                            const std::vector<uint8>& data,
                                            double timestamp) {
   // Not correct right now. http://crbug.com/374341.
   if (!send_thread_.IsRunning())
     send_thread_.Start();
 
@@ skipping 1055 matching lines @@
   source_map_[AddrToInt(client_id, port_id)] = port_index;
   return true;
 }
 
 MidiManager* MidiManager::Create() {
   return new MidiManagerAlsa();
 }
 
 }  // namespace midi
 }  // namespace media