Web MIDI: distributes MIDIPort information asynchronously

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 <string>
 
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
@@ skipping 61 matching lines @@
 };
 
 class FakeMidiManagerClient : public MidiManagerClient {
  public:
   explicit FakeMidiManagerClient(Logger* logger)
       : complete_start_session_(false),
         result_(MIDI_NOT_SUPPORTED),
         logger_(logger) {}
   virtual ~FakeMidiManagerClient() {}
 
+  virtual void AddInputPort(const MidiPortInfo& info) override {
+    input_ports_.push_back(info);
+  }
+  virtual void AddOutputPort(const MidiPortInfo& info) override {
+    output_ports_.push_back(info);
+  }
+
   virtual void CompleteStartSession(MidiResult result) override {
     complete_start_session_ = true;
     result_ = result;
   }
 
   virtual void ReceiveMidiData(uint32 port_index,
                                const uint8* data,
                                size_t size,
                                double timestamp) override {
     logger_->AddLog("MidiManagerClient::ReceiveMidiData ");
     logger_->AddLog(base::StringPrintf("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");
   }
 
   virtual 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)));
   }
 
   bool complete_start_session_;
   MidiResult result_;
+  MidiPortInfoList input_ports_;
+  MidiPortInfoList output_ports_;
 
  private:
   Logger* logger_;
 
   DISALLOW_COPY_AND_ASSIGN(FakeMidiManagerClient);
 };
 
 class TestUsbMidiDeviceFactory : public UsbMidiDevice::Factory {
  public:
   TestUsbMidiDeviceFactory() {}
@@ skipping 60 matching lines @@
 
   void RunCallbackUntilCallbackInvoked(
       bool result, UsbMidiDevice::Devices* devices) {
     factory_->callback_.Run(result, devices);
     while (!client_->complete_start_session_) {
       base::RunLoop run_loop;
       run_loop.RunUntilIdle();
     }
   }
 
+  const MidiPortInfoList& input_ports() { return client_->input_ports_; }
+  const MidiPortInfoList& output_ports() { return client_->output_ports_; }
+
   scoped_ptr<MidiManagerUsbForTesting> manager_;
   scoped_ptr<FakeMidiManagerClient> client_;
   // Owned by manager_.
   TestUsbMidiDeviceFactory* factory_;
   Logger logger_;
 
  private:
   scoped_ptr<base::MessageLoop> message_loop_;
 
   DISALLOW_COPY_AND_ASSIGN(MidiManagerUsbTest);
@@ skipping 20 matching lines @@
   };
   device->SetDescriptor(ToVector(descriptor));
 
   Initialize();
   ScopedVector<UsbMidiDevice> devices;
   devices.push_back(device.release());
   EXPECT_FALSE(IsInitializationCallbackInvoked());
   RunCallbackUntilCallbackInvoked(true, &devices);
   EXPECT_EQ(MIDI_OK, GetInitializationResult());
 
-  ASSERT_EQ(1u, manager_->input_ports().size());
-  ASSERT_EQ(2u, manager_->output_ports().size());
+  ASSERT_EQ(1u, input_ports().size());
+  ASSERT_EQ(2u, output_ports().size());
   ASSERT_TRUE(manager_->input_stream());
   std::vector<UsbMidiInputStream::JackUniqueKey> keys =
       manager_->input_stream()->RegisteredJackKeysForTesting();
   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, keys.size());
   EXPECT_EQ(2, keys[0].endpoint_number);
 
   EXPECT_EQ("UsbMidiDevice::GetDescriptor\n", logger_.TakeLog());
@@ skipping 109 matching lines @@
             "data = 0x90 0x45 0x7f\n"
             "MidiManagerClient::ReceiveMidiData port_index = 0 "
             "data = 0xf0 0x00 0x01\n"
             "MidiManagerClient::ReceiveMidiData port_index = 0 data = 0xf7\n",
             logger_.TakeLog());
 }
 
 }  // namespace
 
 }  // namespace media