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

media/midi/midi_manager_usb_unittest.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 <stddef.h>
 #include <stdint.h>
 #include <memory>
 #include <string>
@@ skipping 77 matching lines @@
   std::string device_version_;
   Logger* logger_;
 
   DISALLOW_COPY_AND_ASSIGN(FakeUsbMidiDevice);
 };
 
 class FakeMidiManagerClient : public MidiManagerClient {
  public:
   explicit FakeMidiManagerClient(Logger* logger)
       : complete_start_session_(false),
-        result_(Result::NOT_SUPPORTED),
+        result_(mojom::Result::NOT_SUPPORTED),
         logger_(logger) {}
   ~FakeMidiManagerClient() override {}
 
   void AddInputPort(const MidiPortInfo& info) override {
     input_ports_.push_back(info);
   }
 
   void AddOutputPort(const MidiPortInfo& info) override {
     output_ports_.push_back(info);
   }
 
   void SetInputPortState(uint32_t port_index, MidiPortState state) override {}
 
   void SetOutputPortState(uint32_t port_index, MidiPortState state) override {}
 
-  void CompleteStartSession(Result result) override {
+  void CompleteStartSession(mojom::Result result) override {
     complete_start_session_ = true;
     result_ = result;
   }
 
   void ReceiveMidiData(uint32_t port_index,
                        const uint8_t* data,
                        size_t size,
                        double timestamp) override {
     logger_->AddLog("MidiManagerClient::ReceiveMidiData ");
     logger_->AddLog(
         base::StringPrintf("usb:port_index = %d data =", port_index));
     for (size_t i = 0; i < size; ++i)
       logger_->AddLog(base::StringPrintf(" 0x%02x", data[i]));
     logger_->AddLog("\n");
   }
 
   void AccumulateMidiBytesSent(size_t size) override {
     logger_->AddLog("MidiManagerClient::AccumulateMidiBytesSent ");
     // Windows has no "%zu".
     logger_->AddLog(base::StringPrintf("size = %u\n",
                                        static_cast<unsigned>(size)));
   }
 
   void Detach() override {}
 
   bool complete_start_session_;
-  Result result_;
+  mojom::Result result_;
   MidiPortInfoList input_ports_;
   MidiPortInfoList output_ports_;
 
  private:
   Logger* logger_;
 
   DISALLOW_COPY_AND_ASSIGN(FakeMidiManagerClient);
 };
 
 class TestUsbMidiDeviceFactory : public UsbMidiDevice::Factory {
@@ skipping 11 matching lines @@
   DISALLOW_COPY_AND_ASSIGN(TestUsbMidiDeviceFactory);
 };
 
 class MidiManagerUsbForTesting : public MidiManagerUsb {
  public:
   explicit MidiManagerUsbForTesting(
       std::unique_ptr<UsbMidiDevice::Factory> device_factory)
       : MidiManagerUsb(std::move(device_factory)) {}
   ~MidiManagerUsbForTesting() override {}
 
-  void CallCompleteInitialization(Result result) {
+  void CallCompleteInitialization(mojom::Result result) {
     CompleteInitialization(result);
     base::RunLoop run_loop;
     run_loop.RunUntilIdle();
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(MidiManagerUsbForTesting);
 };
 
 class MidiManagerUsbTest : public ::testing::Test {
@@ skipping 22 matching lines @@
   }
 
   void Finalize() {
     manager_->EndSession(client_.get());
   }
 
   bool IsInitializationCallbackInvoked() {
     return client_->complete_start_session_;
   }
 
-  Result GetInitializationResult() { return client_->result_; }
+  mojom::Result GetInitializationResult() { return client_->result_; }
 
   void RunCallbackUntilCallbackInvoked(
       bool result, UsbMidiDevice::Devices* devices) {
     factory_->callback_.Run(result, devices);
     while (!client_->complete_start_session_) {
       base::RunLoop run_loop;
       run_loop.RunUntilIdle();
     }
   }
 
@@ skipping 32 matching lines @@
   device->SetDescriptors(ToVector(descriptors));
   device->SetManufacturer("vendor1");
   device->SetProductName("device1");
   device->SetDeviceVersion("1.02");
 
   Initialize();
   ScopedVector<UsbMidiDevice> devices;
   devices.push_back(std::move(device));
   EXPECT_FALSE(IsInitializationCallbackInvoked());
   RunCallbackUntilCallbackInvoked(true, &devices);
-  EXPECT_EQ(Result::OK, GetInitializationResult());
+  EXPECT_EQ(mojom::Result::OK, GetInitializationResult());
 
   ASSERT_EQ(1u, input_ports().size());
   EXPECT_EQ("usb:port-0-2", input_ports()[0].id);
   EXPECT_EQ("vendor1", input_ports()[0].manufacturer);
   EXPECT_EQ("device1", input_ports()[0].name);
   EXPECT_EQ("1.02", input_ports()[0].version);
 
   ASSERT_EQ(2u, output_ports().size());
   EXPECT_EQ("usb:port-0-0", output_ports()[0].id);
   EXPECT_EQ("vendor1", output_ports()[0].manufacturer);
@@ skipping 40 matching lines @@
   device2->SetManufacturer("vendor2");
   device2->SetProductName("device2");
   device2->SetDeviceVersion("98.76");
 
   Initialize();
   ScopedVector<UsbMidiDevice> devices;
   devices.push_back(std::move(device1));
   devices.push_back(std::move(device2));
   EXPECT_FALSE(IsInitializationCallbackInvoked());
   RunCallbackUntilCallbackInvoked(true, &devices);
-  EXPECT_EQ(Result::OK, GetInitializationResult());
+  EXPECT_EQ(mojom::Result::OK, GetInitializationResult());
 
   ASSERT_EQ(2u, input_ports().size());
   EXPECT_EQ("usb:port-0-2", input_ports()[0].id);
   EXPECT_EQ("vendor1", input_ports()[0].manufacturer);
   EXPECT_EQ("device1", input_ports()[0].name);
   EXPECT_EQ("1.02", input_ports()[0].version);
   EXPECT_EQ("usb:port-1-2", input_ports()[1].id);
   EXPECT_EQ("vendor2", input_ports()[1].manufacturer);
   EXPECT_EQ("device2", input_ports()[1].name);
   EXPECT_EQ("98.76", input_ports()[1].version);
@@ skipping 28 matching lines @@
       "UsbMidiDevice::GetDescriptors\n"
       "UsbMidiDevice::GetDescriptors\n",
       logger_.TakeLog());
 }
 
 TEST_F(MidiManagerUsbTest, InitializeFail) {
   Initialize();
 
   EXPECT_FALSE(IsInitializationCallbackInvoked());
   RunCallbackUntilCallbackInvoked(false, NULL);
-  EXPECT_EQ(Result::INITIALIZATION_ERROR, GetInitializationResult());
+  EXPECT_EQ(mojom::Result::INITIALIZATION_ERROR, GetInitializationResult());
 }
 
 TEST_F(MidiManagerUsbTest, InitializeFailBecauseOfInvalidDescriptors) {
   std::unique_ptr<FakeUsbMidiDevice> device(new FakeUsbMidiDevice(&logger_));
   uint8_t descriptors[] = {0x04};
   device->SetDescriptors(ToVector(descriptors));
 
   Initialize();
   ScopedVector<UsbMidiDevice> devices;
   devices.push_back(std::move(device));
   EXPECT_FALSE(IsInitializationCallbackInvoked());
   RunCallbackUntilCallbackInvoked(true, &devices);
-  EXPECT_EQ(Result::INITIALIZATION_ERROR, GetInitializationResult());
+  EXPECT_EQ(mojom::Result::INITIALIZATION_ERROR, GetInitializationResult());
   EXPECT_EQ("UsbMidiDevice::GetDescriptors\n", logger_.TakeLog());
 }
 
 TEST_F(MidiManagerUsbTest, Send) {
   Initialize();
   std::unique_ptr<FakeUsbMidiDevice> device(new FakeUsbMidiDevice(&logger_));
   uint8_t descriptors[] = {
       0x12, 0x01, 0x10, 0x01, 0x00, 0x00, 0x00, 0x08, 0x86, 0x1a, 0x2d, 0x75,
       0x54, 0x02, 0x00, 0x02, 0x00, 0x01, 0x09, 0x02, 0x75, 0x00, 0x02, 0x01,
       0x00, 0x80, 0x30, 0x09, 0x04, 0x00, 0x00, 0x00, 0x01, 0x01, 0x00, 0x00,
@@ skipping 10 matching lines @@
 
   device->SetDescriptors(ToVector(descriptors));
   uint8_t data[] = {
       0x90, 0x45, 0x7f, 0xf0, 0x00, 0x01, 0xf7,
   };
 
   ScopedVector<UsbMidiDevice> devices;
   devices.push_back(std::move(device));
   EXPECT_FALSE(IsInitializationCallbackInvoked());
   RunCallbackUntilCallbackInvoked(true, &devices);
-  EXPECT_EQ(Result::OK, GetInitializationResult());
+  EXPECT_EQ(mojom::Result::OK, GetInitializationResult());
   ASSERT_EQ(2u, manager_->output_streams().size());
 
   manager_->DispatchSendMidiData(client_.get(), 1, ToVector(data), 0);
   // Since UsbMidiDevice::Send is posted as a task, RunLoop should run to
   // invoke the task.
   base::RunLoop run_loop;
   run_loop.RunUntilIdle();
   EXPECT_EQ("UsbMidiDevice::GetDescriptors\n"
             "UsbMidiDevice::Send endpoint = 2 data = "
             "0x19 0x90 0x45 0x7f "
@@ skipping 23 matching lines @@
   device->SetDescriptors(ToVector(descriptors));
   uint8_t data[] = {
       0x90, 0x45, 0x7f, 0xf0, 0x00, 0x01, 0xf7,
   };
 
   Initialize();
   ScopedVector<UsbMidiDevice> devices;
   devices.push_back(std::move(device));
   EXPECT_FALSE(IsInitializationCallbackInvoked());
   RunCallbackUntilCallbackInvoked(true, &devices);
-  EXPECT_EQ(Result::OK, GetInitializationResult());
+  EXPECT_EQ(mojom::Result::OK, GetInitializationResult());
   ASSERT_EQ(2u, manager_->output_streams().size());
   EXPECT_EQ("UsbMidiDevice::GetDescriptors\n", logger_.TakeLog());
 
   // The specified port index is invalid. The manager must ignore the request.
   manager_->DispatchSendMidiData(client_.get(), 99, ToVector(data), 0);
   EXPECT_EQ("", logger_.TakeLog());
 
   // The specified port index is invalid. The manager must ignore the request.
   manager_->DispatchSendMidiData(client_.get(), 2, ToVector(data), 0);
   EXPECT_EQ("", logger_.TakeLog());
@@ skipping 22 matching lines @@
       0x01, 0x49, 0x90, 0x88, 0x99,  // This data should be ignored (CN = 4).
       0x05, 0xf7, 0x00, 0x00,
   };
 
   Initialize();
   ScopedVector<UsbMidiDevice> devices;
   UsbMidiDevice* device_raw = device.get();
   devices.push_back(std::move(device));
   EXPECT_FALSE(IsInitializationCallbackInvoked());
   RunCallbackUntilCallbackInvoked(true, &devices);
-  EXPECT_EQ(Result::OK, GetInitializationResult());
+  EXPECT_EQ(mojom::Result::OK, GetInitializationResult());
 
   manager_->ReceiveUsbMidiData(device_raw, 2, data, arraysize(data),
                                base::TimeTicks());
   Finalize();
 
   EXPECT_EQ(
       "UsbMidiDevice::GetDescriptors\n"
       "MidiManagerClient::ReceiveMidiData usb:port_index = 0 "
       "data = 0x90 0x45 0x7f\n"
       "MidiManagerClient::ReceiveMidiData usb:port_index = 0 "
@@ skipping 15 matching lines @@
       0x00, 0x09, 0x24, 0x03, 0x02, 0x05, 0x01, 0x03, 0x01, 0x00, 0x09, 0x05,
       0x02, 0x02, 0x20, 0x00, 0x00, 0x00, 0x00, 0x06, 0x25, 0x01, 0x02, 0x02,
       0x03, 0x09, 0x05, 0x82, 0x02, 0x20, 0x00, 0x00, 0x00, 0x00, 0x05, 0x25,
       0x01, 0x01, 0x07,
   };
 
   Initialize();
   ScopedVector<UsbMidiDevice> devices;
   EXPECT_FALSE(IsInitializationCallbackInvoked());
   RunCallbackUntilCallbackInvoked(true, &devices);
-  EXPECT_EQ(Result::OK, GetInitializationResult());
+  EXPECT_EQ(mojom::Result::OK, GetInitializationResult());
 
   ASSERT_EQ(0u, input_ports().size());
   ASSERT_EQ(0u, output_ports().size());
   ASSERT_TRUE(manager_->input_stream());
   std::vector<UsbMidiJack> jacks = manager_->input_stream()->jacks();
   ASSERT_EQ(0u, manager_->output_streams().size());
   ASSERT_EQ(0u, jacks.size());
   EXPECT_EQ("", logger_.TakeLog());
 
   std::unique_ptr<FakeUsbMidiDevice> new_device(
       new FakeUsbMidiDevice(&logger_));
   new_device->SetDescriptors(ToVector(descriptors));
   manager_->OnDeviceAttached(std::move(new_device));
 
   ASSERT_EQ(1u, input_ports().size());
   ASSERT_EQ(2u, output_ports().size());
   ASSERT_TRUE(manager_->input_stream());
   jacks = manager_->input_stream()->jacks();
   ASSERT_EQ(2u, manager_->output_streams().size());
   EXPECT_EQ(2u, manager_->output_streams()[0]->jack().jack_id);
   EXPECT_EQ(3u, manager_->output_streams()[1]->jack().jack_id);
   ASSERT_EQ(1u, jacks.size());
   EXPECT_EQ(2, jacks[0].endpoint_number());
   EXPECT_EQ("UsbMidiDevice::GetDescriptors\n", logger_.TakeLog());
 }
 
 }  // namespace
 
 }  // namespace midi