Web MIDI: introduce pending client count limit to start sessions

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 <vector>
+
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace media {
 
 namespace {
 
 class FakeMidiManager : public MidiManager {
  public:
@@ skipping 29 matching lines @@
 
   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),
+        start_session_is_completed_(false) {}
   virtual ~FakeMidiManagerClient() {}
 
   // MidiManagerClient implementation.
   virtual void CompleteStartSession(int client_id, MidiResult result) OVERRIDE {
-    DCHECK_EQ(client_id_, client_id);
+    EXPECT_FALSE(start_session_is_completed_);
+    EXPECT_EQ(client_id_, client_id);
     result_ = result;
+    start_session_is_completed_ = true;
   }
 
   virtual void ReceiveMidiData(uint32 port_index, const uint8* data,
                                size_t size, double timestamp) OVERRIDE {}
   virtual void AccumulateMidiBytesSent(size_t size) OVERRIDE {}
 
   int GetClientId() {
     return client_id_;
   }
 
   MidiResult GetResult() {
     return result_;
   }
 
  private:
   int client_id_;
   MidiResult result_;
+  bool start_session_is_completed_;
 
   DISALLOW_COPY_AND_ASSIGN(FakeMidiManagerClient);
 };
 
 class MidiManagerTest : public ::testing::Test {
  public:
   MidiManagerTest() : manager_(new FakeMidiManager) {}
   virtual ~MidiManagerTest() {}
 
  protected:
@@ skipping 13 matching lines @@
     } 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_);
     }
   }
 
-  void StartTheSecondSession(FakeMidiManagerClient* client) {
-    EXPECT_TRUE(manager_->start_initialization_is_called_);
+  void StartTheNthSession(FakeMidiManagerClient* client, size_t nth) {
+    EXPECT_EQ(nth != 1, manager_->start_initialization_is_called_);
     EXPECT_EQ(0U, manager_->GetClientCount());
-    EXPECT_EQ(1U, manager_->GetPendingClientCount());
+    EXPECT_EQ(nth - 1, manager_->GetPendingClientCount());
 
-    // StartInitialization() should not be called for the second session.
+    // StartInitialization() should not be called for the second and later
+    // sessions.
     manager_->start_initialization_is_called_ = false;
     manager_->StartSession(client, client->GetClientId());
-    EXPECT_FALSE(manager_->start_initialization_is_called_);
+    EXPECT_EQ(nth == 1, manager_->start_initialization_is_called_);
+    manager_->start_initialization_is_called_ = true;
   }
 
   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:
+ protected:
   scoped_ptr<FakeMidiManager> manager_;
 
+ private:
   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);
@@ skipping 20 matching lines @@
   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);
-  StartTheSecondSession(client2.get());
+  StartTheNthSession(client2.get(), 2);
   CompleteInitialization(MIDI_OK);
   EXPECT_EQ(MIDI_OK, client1->GetResult());
   EXPECT_EQ(MIDI_OK, client2->GetResult());
   EndSession(client1.get(), 2U, 1U);
   EndSession(client2.get(), 1U, 0U);
 }
 
+TEST_F(MidiManagerTest, TooManyPendingSessions) {
+  // Push as many client requests for starting session as possible.
+  std::vector<scoped_ptr<FakeMidiManagerClient> > clients;

[yukawa, 2014/05/04 23:45:55]

Note: ScopedVector (base/memory/scoped_vector.h) might be better to avoid
mysterious compile errors since C++11 is not yet available in Chromium.

[Takashi Toyoshima, 2014/05/05 00:59:06]

Oh, it will help me. I'll try it.

+  clients.resize(MidiManager::kMaxPendingClientCount);
+  for (size_t i = 0; i < MidiManager::kMaxPendingClientCount; ++i) {
+    clients[i].reset(new FakeMidiManagerClient(i));
+    StartTheNthSession(clients[i].get(), i + 1);
+  }
+
+  // Push the last client that should be rejected for too many pending requests.
+  scoped_ptr<FakeMidiManagerClient> client(
+      new FakeMidiManagerClient(MidiManager::kMaxPendingClientCount));
+  manager_->start_initialization_is_called_ = false;
+  manager_->StartSession(client.get(), client->GetClientId());
+  EXPECT_FALSE(manager_->start_initialization_is_called_);
+  EXPECT_EQ(MIDI_INITIALIZATION_ERROR, client->GetResult());
+
+  // Other clients still should not receive a result.
+  for (size_t i = 0; i < clients.size(); ++i)
+    EXPECT_EQ(MIDI_NOT_SUPPORTED, clients[i]->GetResult());
+
+  // The result MIDI_OK should be distributed to other clients.
+  CompleteInitialization(MIDI_OK);
+  for (size_t i = 0; i < clients.size(); ++i)
+    EXPECT_EQ(MIDI_OK, clients[i]->GetResult());
+
+  // Close all successful sessions in FIFO order.
+  size_t sessions = clients.size();
+  for (size_t i = 0; i < clients.size(); ++i, --sessions)
+    EndSession(clients[i].get(), sessions, sessions - 1);
+}
+
 }  // namespace
 
 }  // namespace media