Web MIDI: use midi_service.mojom for media::midi::Result

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 <errno.h>
 #include <poll.h>
 #include <stddef.h>
 #include <stdlib.h>
@@ skipping 163 matching lines @@
   base::AutoLock lock(lazy_init_member_lock_);
 
   initialization_thread_checker_.reset(new base::ThreadChecker());
 
   // Create client handles.
   snd_seq_t* tmp_seq = nullptr;
   int err =
       snd_seq_open(&tmp_seq, kAlsaHw, SND_SEQ_OPEN_INPUT, SND_SEQ_NONBLOCK);
   if (err != 0) {
     VLOG(1) << "snd_seq_open fails: " << snd_strerror(err);
-    return CompleteInitialization(Result::INITIALIZATION_ERROR);
+    return CompleteInitialization(mojom::Result::INITIALIZATION_ERROR);
   }
   ScopedSndSeqPtr in_client(tmp_seq);
   tmp_seq = nullptr;
   in_client_id_ = snd_seq_client_id(in_client.get());
 
   err = snd_seq_open(&tmp_seq, kAlsaHw, SND_SEQ_OPEN_OUTPUT, 0);
   if (err != 0) {
     VLOG(1) << "snd_seq_open fails: " << snd_strerror(err);
-    return CompleteInitialization(Result::INITIALIZATION_ERROR);
+    return CompleteInitialization(mojom::Result::INITIALIZATION_ERROR);
   }
   ScopedSndSeqPtr out_client(tmp_seq);
   tmp_seq = nullptr;
   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(Result::INITIALIZATION_ERROR);
+    return CompleteInitialization(mojom::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(Result::INITIALIZATION_ERROR);
+    return CompleteInitialization(mojom::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(Result::INITIALIZATION_ERROR);
+    return CompleteInitialization(mojom::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(Result::INITIALIZATION_ERROR);
+    return CompleteInitialization(mojom::Result::INITIALIZATION_ERROR);
   }
 
   // Initialize decoder.
   snd_midi_event_t* tmp_decoder = nullptr;
   snd_midi_event_new(0, &tmp_decoder);
   ScopedSndMidiEventPtr decoder(tmp_decoder);
   tmp_decoder = nullptr;
   snd_midi_event_no_status(decoder.get(), 1);
 
   // Initialize udev and monitor.
   device::ScopedUdevPtr udev(device::udev_new());
   device::ScopedUdevMonitorPtr udev_monitor(
       device::udev_monitor_new_from_netlink(udev.get(), kUdev));
   if (!udev_monitor.get()) {
     VLOG(1) << "udev_monitor_new_from_netlink fails";
-    return CompleteInitialization(Result::INITIALIZATION_ERROR);
+    return CompleteInitialization(mojom::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(Result::INITIALIZATION_ERROR);
+    return CompleteInitialization(mojom::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(Result::INITIALIZATION_ERROR);
+    return CompleteInitialization(mojom::Result::INITIALIZATION_ERROR);
   }
 
   // Success! Now, initialize members from the temporaries. Do not
   // initialize these earlier, since they need to be destroyed by the
   // thread that calls Finalize(), not the destructor thread (and we
   // check this in the destructor).
   in_client_.reset(in_client.release());
   out_client_.reset(out_client.release());
   decoder_.reset(decoder.release());
   udev_.reset(udev.release());
   udev_monitor_.reset(udev_monitor.release());
 
   // Generate hotplug events for existing ports.
   // TODO(agoode): Check the return value for failure.
   EnumerateAlsaPorts();
 
   // Generate hotplug events for existing udev devices. This must be done
   // after udev_monitor_enable_receiving() is called. See the algorithm
   // at http://www.signal11.us/oss/udev/.
   EnumerateUdevCards();
 
   // Start processing events. Don't do this before enumeration of both
   // ALSA and udev.
   event_thread_.Start();
   event_thread_.task_runner()->PostTask(
       FROM_HERE,
       base::Bind(&MidiManagerAlsa::ScheduleEventLoop, base::Unretained(this)));
   send_thread_.Start();
 
-  CompleteInitialization(Result::OK);
+  CompleteInitialization(mojom::Result::OK);
 }
 
 void MidiManagerAlsa::Finalize() {
   base::AutoLock lock(lazy_init_member_lock_);
   DCHECK(initialization_thread_checker_->CalledOnValidThread());
 
   // Tell the event thread it will soon be time to shut down. This gives
   // us assurance the thread will stop in case the SND_SEQ_EVENT_CLIENT_EXIT
   // message is lost.
   {
@@ skipping 1091 matching lines @@
   // Update our map.
   source_map_[AddrToInt(client_id, port_id)] = port_index;
   return true;
 }
 
 MidiManager* MidiManager::Create() {
   return new MidiManagerAlsa();
 }
 
 }  // namespace midi