Upstream version 7.36.149.0

[platform/framework/web/crosswalk.git] / src / media / midi / midi_manager_usb_unittest.cc

diff --git a/src/media/midi/midi_manager_usb_unittest.cc b/src/media/midi/midi_manager_usb_unittest.cc
index 567b60c..88bfd93 100644 (file)
--- a/src/media/midi/midi_manager_usb_unittest.cc
+++ b/src/media/midi/midi_manager_usb_unittest.cc
@@ -6,7 +6,10 @@
 
 #include <string>
 
+#include "base/message_loop/message_loop.h"
+#include "base/run_loop.h"
 #include "base/strings/stringprintf.h"
+#include "base/time/time.h"
 #include "media/midi/usb_midi_device.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
@@ -70,9 +73,17 @@ class FakeUsbMidiDevice : public UsbMidiDevice {
 
 class FakeMidiManagerClient : public MidiManagerClient {
  public:
-  explicit FakeMidiManagerClient(Logger* logger) : logger_(logger) {}
+  explicit FakeMidiManagerClient(Logger* logger)
+      : complete_start_session_(false),
+        result_(MIDI_NOT_SUPPORTED),
+        logger_(logger) {}
   virtual ~FakeMidiManagerClient() {}
 
+  virtual void CompleteStartSession(int client_id, MidiResult result) OVERRIDE {
+    complete_start_session_ = true;
+    result_ = result;
+  }
+
   virtual void ReceiveMidiData(uint32 port_index,
                                const uint8* data,
                                size_t size,
@@ -91,6 +102,9 @@ class FakeMidiManagerClient : public MidiManagerClient {
                                        static_cast<unsigned>(size)));
   }
 
+  bool complete_start_session_;
+  MidiResult result_;
+
  private:
   Logger* logger_;
 
@@ -112,14 +126,30 @@ class TestUsbMidiDeviceFactory : public UsbMidiDevice::Factory {
   DISALLOW_COPY_AND_ASSIGN(TestUsbMidiDeviceFactory);
 };
 
+class MidiManagerUsbForTesting : public MidiManagerUsb {
+ public:
+  explicit MidiManagerUsbForTesting(
+      scoped_ptr<UsbMidiDevice::Factory> device_factory)
+      : MidiManagerUsb(device_factory.PassAs<UsbMidiDevice::Factory>()) {}
+  virtual ~MidiManagerUsbForTesting() {}
+
+  void CallCompleteInitialization(MidiResult result) {
+    CompleteInitialization(result);
+    base::RunLoop run_loop;
+    run_loop.RunUntilIdle();
+  }
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(MidiManagerUsbForTesting);
+};
+
 class MidiManagerUsbTest : public ::testing::Test {
  public:
-  MidiManagerUsbTest()
-      : initialize_callback_run_(false), initialize_result_(false) {
+  MidiManagerUsbTest() : message_loop_(new base::MessageLoop) {
     scoped_ptr<TestUsbMidiDeviceFactory> factory(new TestUsbMidiDeviceFactory);
     factory_ = factory.get();
     manager_.reset(
-        new MidiManagerUsb(factory.PassAs<UsbMidiDevice::Factory>()));
+        new MidiManagerUsbForTesting(factory.PassAs<UsbMidiDevice::Factory>()));
   }
   virtual ~MidiManagerUsbTest() {
     std::string leftover_logs = logger_.TakeLog();
@@ -130,24 +160,39 @@ class MidiManagerUsbTest : public ::testing::Test {
 
  protected:
   void Initialize() {
-    manager_->Initialize(base::Bind(&MidiManagerUsbTest::OnInitializeDone,
-                                    base::Unretained(this)));
+    client_.reset(new FakeMidiManagerClient(&logger_));
+    manager_->StartSession(client_.get(), 0);
   }
 
-  void OnInitializeDone(bool result) {
-    initialize_callback_run_ = true;
-    initialize_result_ = result;
+  void Finalize() {
+    manager_->EndSession(client_.get());
   }
 
-  bool initialize_callback_run_;
-  bool initialize_result_;
+  bool IsInitializationCallbackInvoked() {
+    return client_->complete_start_session_;
+  }
+
+  MidiResult GetInitializationResult() {
+    return client_->result_;
+  }
+
+  void RunCallbackUntilCallbackInvoked(
+      bool result, UsbMidiDevice::Devices* devices) {
+    factory_->callback_.Run(result, devices);
+    base::RunLoop run_loop;
+    while (!client_->complete_start_session_)
+      run_loop.RunUntilIdle();
+  }
 
-  scoped_ptr<MidiManagerUsb> manager_;
+  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);
 };
 
@@ -175,10 +220,9 @@ TEST_F(MidiManagerUsbTest, Initialize) {
   Initialize();
   ScopedVector<UsbMidiDevice> devices;
   devices.push_back(device.release());
-  EXPECT_FALSE(initialize_callback_run_);
-  factory_->callback_.Run(true, &devices);
-  EXPECT_TRUE(initialize_callback_run_);
-  EXPECT_TRUE(initialize_result_);
+  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());
@@ -197,10 +241,9 @@ TEST_F(MidiManagerUsbTest, Initialize) {
 TEST_F(MidiManagerUsbTest, InitializeFail) {
   Initialize();
 
-  EXPECT_FALSE(initialize_callback_run_);
-  factory_->callback_.Run(false, NULL);
-  EXPECT_TRUE(initialize_callback_run_);
-  EXPECT_FALSE(initialize_result_);
+  EXPECT_FALSE(IsInitializationCallbackInvoked());
+  RunCallbackUntilCallbackInvoked(false, NULL);
+  EXPECT_EQ(MIDI_INITIALIZATION_ERROR, GetInitializationResult());
 }
 
 TEST_F(MidiManagerUsbTest, InitializeFailBecauseOfInvalidDescriptor) {
@@ -211,10 +254,9 @@ TEST_F(MidiManagerUsbTest, InitializeFailBecauseOfInvalidDescriptor) {
   Initialize();
   ScopedVector<UsbMidiDevice> devices;
   devices.push_back(device.release());
-  EXPECT_FALSE(initialize_callback_run_);
-  factory_->callback_.Run(true, &devices);
-  EXPECT_TRUE(initialize_callback_run_);
-  EXPECT_FALSE(initialize_result_);
+  EXPECT_FALSE(IsInitializationCallbackInvoked());
+  RunCallbackUntilCallbackInvoked(true, &devices);
+  EXPECT_EQ(MIDI_INITIALIZATION_ERROR, GetInitializationResult());
   EXPECT_EQ("UsbMidiDevice::GetDescriptor\n", logger_.TakeLog());
 }
 
@@ -247,10 +289,9 @@ TEST_F(MidiManagerUsbTest, Send) {
   Initialize();
   ScopedVector<UsbMidiDevice> devices;
   devices.push_back(device.release());
-  EXPECT_FALSE(initialize_callback_run_);
-  factory_->callback_.Run(true, &devices);
-  ASSERT_TRUE(initialize_callback_run_);
-  ASSERT_TRUE(initialize_result_);
+  EXPECT_FALSE(IsInitializationCallbackInvoked());
+  RunCallbackUntilCallbackInvoked(true, &devices);
+  EXPECT_EQ(MIDI_OK, GetInitializationResult());
   ASSERT_EQ(2u, manager_->output_streams().size());
 
   manager_->DispatchSendMidiData(&client, 1, ToVector(data), 0);
@@ -265,7 +306,6 @@ TEST_F(MidiManagerUsbTest, Send) {
 
 TEST_F(MidiManagerUsbTest, Receive) {
   scoped_ptr<FakeUsbMidiDevice> device(new FakeUsbMidiDevice(&logger_));
-  FakeMidiManagerClient client(&logger_);
   uint8 descriptor[] = {
     0x12, 0x01, 0x10, 0x01, 0x00, 0x00, 0x00, 0x08, 0x86, 0x1a,
     0x2d, 0x75, 0x54, 0x02, 0x00, 0x02, 0x00, 0x01, 0x09, 0x02,
@@ -295,14 +335,13 @@ TEST_F(MidiManagerUsbTest, Receive) {
   ScopedVector<UsbMidiDevice> devices;
   UsbMidiDevice* device_raw = device.get();
   devices.push_back(device.release());
-  EXPECT_FALSE(initialize_callback_run_);
-  factory_->callback_.Run(true, &devices);
-  ASSERT_TRUE(initialize_callback_run_);
-  ASSERT_TRUE(initialize_result_);
-
-  manager_->StartSession(&client);
-  manager_->ReceiveUsbMidiData(device_raw, 2, data, arraysize(data), 0);
-  manager_->EndSession(&client);
+  EXPECT_FALSE(IsInitializationCallbackInvoked());
+  RunCallbackUntilCallbackInvoked(true, &devices);
+  EXPECT_EQ(MIDI_OK, GetInitializationResult());
+
+  manager_->ReceiveUsbMidiData(device_raw, 2, data, arraysize(data),
+                               base::TimeTicks());
+  Finalize();
 
   EXPECT_EQ("UsbMidiDevice::GetDescriptor\n"
             "MidiManagerClient::ReceiveMidiData port_index = 0 "