Web MIDI: add an unit test to check MidiManager instantiation

media/midi/midi_manager_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.h"
 
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
+#include "base/run_loop.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace media {
 
 namespace {
 
 class FakeMidiManager : public MidiManager {
  public:
-  FakeMidiManager()
-      : start_initialization_is_called_(false),
-        complete_initialization_synchronously_(false) {}
+  FakeMidiManager() : start_initialization_is_called_(false) {}
   virtual ~FakeMidiManager() {}
 
   // MidiManager implementation.
   virtual void StartInitialization() OVERRIDE {
     start_initialization_is_called_ = true;
-    if (complete_initialization_synchronously_)
-      CompleteInitialization(MIDI_OK);
   }
 
   virtual void DispatchSendMidiData(MidiManagerClient* client,
                                     uint32 port_index,
                                     const std::vector<uint8>& data,
                                     double timestamp) OVERRIDE {}
 
   // Utility functions for testing.
   void CallCompleteInitialization(MidiResult result) {
     CompleteInitialization(result);
   }
 
   size_t GetClientCount() {
     return clients_.size();
   }
 
   size_t GetPendingClientCount() {
     return pending_clients_.size();
   }
 
   bool start_initialization_is_called_;
-  bool complete_initialization_synchronously_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(FakeMidiManager);
 };
 
 class FakeMidiManagerClient : public MidiManagerClient {
  public:
-  FakeMidiManagerClient(int client_id) : client_id_(client_id) {}
+  explicit FakeMidiManagerClient(int client_id)
+      : client_id_(client_id),
+        result_(MIDI_NOT_SUPPORTED),
+        wait_for_result_(true) {}
   virtual ~FakeMidiManagerClient() {}
 
   // MidiManagerClient implementation.
   virtual void CompleteStartSession(int client_id, MidiResult result) OVERRIDE {
-    DCHECK_EQ(client_id_, client_id);
+    CHECK_EQ(client_id_, client_id);
     result_ = result;
+    wait_for_result_ = false;
   }
 
   virtual void ReceiveMidiData(uint32 port_index, const uint8* data,
                                size_t size, double timestamp) OVERRIDE {}
   virtual void AccumulateMidiBytesSent(size_t size) OVERRIDE {}
 
-  int GetClientId() {
+  int GetClientId() const {
     return client_id_;
   }
 
-  MidiResult GetResult() {
+  MidiResult GetResult() const {
     return result_;
   }
 
+  MidiResult WaitForResult() {
+    base::RunLoop run_loop;
+    while (wait_for_result_)

[yukawa, 2014/05/05 04:07:36]

Can we assume that |wait_for_result_| is modified in the same thread?  If we
assume particular thread model and memory model, we might want to leave some
comment here.

[Takashi Toyoshima, 2014/05/06 01:58:18]

Done.

+      run_loop.RunUntilIdle();
+    return GetResult();
+  }
+
  private:
   int client_id_;
   MidiResult result_;
+  bool wait_for_result_;
 
   DISALLOW_COPY_AND_ASSIGN(FakeMidiManagerClient);
 };
 
 class MidiManagerTest : public ::testing::Test {
  public:
-  MidiManagerTest() : manager_(new FakeMidiManager) {}
+  MidiManagerTest()
+      : message_loop_(new base::MessageLoop), manager_(new FakeMidiManager) {}
   virtual ~MidiManagerTest() {}
 
  protected:
-  void StartTheFirstSession(FakeMidiManagerClient* client,
-                            bool complete_initialization_synchronously) {
-    manager_->complete_initialization_synchronously_ =
-        complete_initialization_synchronously;
+  void StartTheFirstSession(FakeMidiManagerClient* client) {
     EXPECT_FALSE(manager_->start_initialization_is_called_);
     EXPECT_EQ(0U, manager_->GetClientCount());
     EXPECT_EQ(0U, manager_->GetPendingClientCount());
     manager_->StartSession(client, client->GetClientId());
-    if (complete_initialization_synchronously) {
-      EXPECT_EQ(1U, manager_->GetClientCount());
-      EXPECT_EQ(0U, manager_->GetPendingClientCount());
-      EXPECT_TRUE(manager_->start_initialization_is_called_);
-      EXPECT_EQ(MIDI_OK, client->GetResult());
-    } else {
-      EXPECT_EQ(0U, manager_->GetClientCount());
-      EXPECT_EQ(1U, manager_->GetPendingClientCount());
-      EXPECT_TRUE(manager_->start_initialization_is_called_);
-      EXPECT_EQ(0U, manager_->GetClientCount());
-      EXPECT_EQ(1U, manager_->GetPendingClientCount());
-      EXPECT_TRUE(manager_->start_initialization_is_called_);
-    }
+    EXPECT_EQ(0U, manager_->GetClientCount());
+    EXPECT_EQ(1U, manager_->GetPendingClientCount());
+    EXPECT_TRUE(manager_->start_initialization_is_called_);
+    EXPECT_EQ(0U, manager_->GetClientCount());
+    EXPECT_EQ(1U, manager_->GetPendingClientCount());
+    EXPECT_TRUE(manager_->start_initialization_is_called_);
   }
 
   void StartTheSecondSession(FakeMidiManagerClient* client) {
     EXPECT_TRUE(manager_->start_initialization_is_called_);
     EXPECT_EQ(0U, manager_->GetClientCount());
     EXPECT_EQ(1U, manager_->GetPendingClientCount());
 
     // StartInitialization() should not be called for the second session.
     manager_->start_initialization_is_called_ = false;
     manager_->StartSession(client, client->GetClientId());
     EXPECT_FALSE(manager_->start_initialization_is_called_);
   }
 
   void EndSession(FakeMidiManagerClient* client, size_t before, size_t after) {
     EXPECT_EQ(before, manager_->GetClientCount());
     manager_->EndSession(client);
     EXPECT_EQ(after, manager_->GetClientCount());
   }
 
   void CompleteInitialization(MidiResult result) {
     manager_->CallCompleteInitialization(result);
   }
 
  private:
+  scoped_ptr<base::MessageLoop> message_loop_;
   scoped_ptr<FakeMidiManager> manager_;
 
   DISALLOW_COPY_AND_ASSIGN(MidiManagerTest);
 };
 
-// Check if calling CompleteInitialization() does not acquire the same lock
-// on the same thread.
-TEST_F(MidiManagerTest, StartAndEndSessionSynchronously) {
-  scoped_ptr<FakeMidiManagerClient> client;
-  client.reset(new FakeMidiManagerClient(0));
-
-  StartTheFirstSession(client.get(), true);
-  EndSession(client.get(), 1U, 0U);
-}
-
 TEST_F(MidiManagerTest, StartAndEndSession) {
   scoped_ptr<FakeMidiManagerClient> client;
   client.reset(new FakeMidiManagerClient(0));
 
-  StartTheFirstSession(client.get(), false);
+  StartTheFirstSession(client.get());
   CompleteInitialization(MIDI_OK);
-  EXPECT_EQ(MIDI_OK, client->GetResult());
+  EXPECT_EQ(MIDI_OK, client->WaitForResult());
   EndSession(client.get(), 1U, 0U);
 }
 
 TEST_F(MidiManagerTest, StartAndEndSessionWithError) {
   scoped_ptr<FakeMidiManagerClient> client;
   client.reset(new FakeMidiManagerClient(1));
 
-  StartTheFirstSession(client.get(), false);
+  StartTheFirstSession(client.get());
   CompleteInitialization(MIDI_INITIALIZATION_ERROR);
-  EXPECT_EQ(MIDI_INITIALIZATION_ERROR, client->GetResult());
+  EXPECT_EQ(MIDI_INITIALIZATION_ERROR, client->WaitForResult());
   EndSession(client.get(), 0U, 0U);
 }
 
 TEST_F(MidiManagerTest, StartMultipleSessions) {
   scoped_ptr<FakeMidiManagerClient> client1;
   scoped_ptr<FakeMidiManagerClient> client2;
   client1.reset(new FakeMidiManagerClient(0));
   client2.reset(new FakeMidiManagerClient(1));
 
-  StartTheFirstSession(client1.get(), false);
+  StartTheFirstSession(client1.get());
   StartTheSecondSession(client2.get());
   CompleteInitialization(MIDI_OK);
-  EXPECT_EQ(MIDI_OK, client1->GetResult());
-  EXPECT_EQ(MIDI_OK, client2->GetResult());
+  EXPECT_EQ(MIDI_OK, client1->WaitForResult());
+  EXPECT_EQ(MIDI_OK, client2->WaitForResult());
   EndSession(client1.get(), 2U, 1U);
   EndSession(client2.get(), 1U, 0U);
 }
 
+TEST_F(MidiManagerTest, CreateMidiManager) {
+  scoped_ptr<FakeMidiManagerClient> client;
+  client.reset(new FakeMidiManagerClient(0));
+
+  scoped_ptr<MidiManager> manager(MidiManager::Create());
+  manager->StartSession(client.get(), client->GetClientId());
+  EXPECT_EQ(MIDI_OK, client->WaitForResult());
+}
+
 }  // namespace
 
 }  // namespace media