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

media/midi/midi_manager_usb.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_usb.h"
 
 #include "base/logging.h"
 #include "base/message_loop/message_loop.h"
 #include "base/strings/stringprintf.h"
 #include "media/midi/midi_scheduler.h"
 #include "media/midi/usb_midi_descriptor_parser.h"
 
 namespace media {
 namespace midi {
 
 MidiManagerUsb::MidiManagerUsb(scoped_ptr<UsbMidiDevice::Factory> factory)
     : device_factory_(factory.Pass()) {
 }
 
 MidiManagerUsb::~MidiManagerUsb() {
 }
 
 void MidiManagerUsb::StartInitialization() {
   Initialize(
       base::Bind(&MidiManager::CompleteInitialization, base::Unretained(this)));
 }
 
-void MidiManagerUsb::Initialize(
-    base::Callback<void(MidiResult result)> callback) {
+void MidiManagerUsb::Initialize(base::Callback<void(Result result)> callback) {
   initialize_callback_ = callback;
   scheduler_.reset(new MidiScheduler(this));
   // This is safe because EnumerateDevices cancels the operation on destruction.
   device_factory_->EnumerateDevices(
       this,
       base::Bind(&MidiManagerUsb::OnEnumerateDevicesDone,
                  base::Unretained(this)));
 }
 
 void MidiManagerUsb::DispatchSendMidiData(MidiManagerClient* client,
@@ skipping 56 matching lines @@
                                     const uint8* data,
                                     size_t size,
                                     base::TimeTicks time) {
   ReceiveMidiData(static_cast<uint32>(jack_index), data, size, time);
 }
 
 
 void MidiManagerUsb::OnEnumerateDevicesDone(bool result,
                                             UsbMidiDevice::Devices* devices) {
   if (!result) {
-    initialize_callback_.Run(MIDI_INITIALIZATION_ERROR);
+    initialize_callback_.Run(Result::INITIALIZATION_ERROR);
     return;
   }
   input_stream_.reset(new UsbMidiInputStream(this));
   devices->swap(devices_);
   for (size_t i = 0; i < devices_.size(); ++i) {
     if (!AddPorts(devices_[i], static_cast<int>(i))) {
-      initialize_callback_.Run(MIDI_INITIALIZATION_ERROR);
+      initialize_callback_.Run(Result::INITIALIZATION_ERROR);
       return;
     }
   }
-  initialize_callback_.Run(MIDI_OK);
+  initialize_callback_.Run(Result::OK);
 }
 
 bool MidiManagerUsb::AddPorts(UsbMidiDevice* device, int device_id) {
   UsbMidiDescriptorParser parser;
   std::vector<uint8> descriptor = device->GetDescriptors();
   const uint8* data = descriptor.size() > 0 ? &descriptor[0] : NULL;
   std::vector<UsbMidiJack> jacks;
   bool parse_result = parser.Parse(device,
                                    data,
                                    descriptor.size(),
@@ skipping 20 matching lines @@
       input_stream_->Add(jacks[j]);
       AddInputPort(MidiPortInfo(id, manufacturer, product_name, version,
                                 MIDI_PORT_OPENED));
     }
   }
   return true;
 }
 
 }  // namespace midi
 }  // namespace media