Update To 11.40.268.0

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

diff --git a/src/media/midi/midi_manager_unittest.cc b/src/media/midi/midi_manager_unittest.cc
index 0350813..40d9152 100644 (file)
--- a/src/media/midi/midi_manager_unittest.cc
+++ b/src/media/midi/midi_manager_unittest.cc
@@ -6,9 +6,11 @@
 
 #include <vector>
 
+#include "base/bind.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/scoped_vector.h"
+#include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
@@ -19,17 +21,17 @@ namespace {
 class FakeMidiManager : public MidiManager {
  public:
   FakeMidiManager() : start_initialization_is_called_(false) {}
-  virtual ~FakeMidiManager() {}
+  ~FakeMidiManager() override {}
 
   // MidiManager implementation.
-  virtual void StartInitialization() OVERRIDE {
+  void StartInitialization() override {
     start_initialization_is_called_ = true;
   }
 
-  virtual void DispatchSendMidiData(MidiManagerClient* client,
-                                    uint32 port_index,
-                                    const std::vector<uint8>& data,
-                                    double timestamp) OVERRIDE {}
+  void DispatchSendMidiData(MidiManagerClient* client,
+                            uint32 port_index,
+                            const std::vector<uint8>& data,
+                            double timestamp) override {}
 
   // Utility functions for testing.
   void CallCompleteInitialization(MidiResult result) {
@@ -52,38 +54,38 @@ class FakeMidiManager : public MidiManager {
 
 class FakeMidiManagerClient : public MidiManagerClient {
  public:
-  explicit FakeMidiManagerClient(int client_id)
-      : client_id_(client_id),
-        result_(MIDI_NOT_SUPPORTED),
+  FakeMidiManagerClient()
+      : result_(MIDI_NOT_SUPPORTED),
         wait_for_result_(true) {}
-  virtual ~FakeMidiManagerClient() {}
+  ~FakeMidiManagerClient() override {}
 
   // MidiManagerClient implementation.
-  virtual void CompleteStartSession(int client_id, MidiResult result) OVERRIDE {
+  void AddInputPort(const MidiPortInfo& info) override {}
+  void AddOutputPort(const MidiPortInfo& info) override {}
+
+  void CompleteStartSession(MidiResult result) override {
     EXPECT_TRUE(wait_for_result_);
-    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 {}
+  void ReceiveMidiData(uint32 port_index,
+                       const uint8* data,
+                       size_t size,
+                       double timestamp) override {}
+  void AccumulateMidiBytesSent(size_t size) override {}
 
-  int client_id() const { return client_id_; }
   MidiResult result() const { return result_; }
 
   MidiResult WaitForResult() {
-    base::RunLoop run_loop;
-    // CompleteStartSession() is called inside the message loop on the same
-    // thread. Protection for |wait_for_result_| is not needed.
-    while (wait_for_result_)
+    while (wait_for_result_) {
+      base::RunLoop run_loop;
       run_loop.RunUntilIdle();
+    }
     return result();
   }
 
  private:
-  int client_id_;
   MidiResult result_;
   bool wait_for_result_;
 
@@ -95,14 +97,14 @@ class MidiManagerTest : public ::testing::Test {
   MidiManagerTest()
       : manager_(new FakeMidiManager),
         message_loop_(new base::MessageLoop) {}
-  virtual ~MidiManagerTest() {}
+  ~MidiManagerTest() override {}
 
  protected:
   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->client_id());
+    manager_->StartSession(client);
     EXPECT_EQ(0U, manager_->GetClientCount());
     EXPECT_EQ(1U, manager_->GetPendingClientCount());
     EXPECT_TRUE(manager_->start_initialization_is_called_);
@@ -119,7 +121,7 @@ class MidiManagerTest : public ::testing::Test {
     // StartInitialization() should not be called for the second and later
     // sessions.
     manager_->start_initialization_is_called_ = false;
-    manager_->StartSession(client, client->client_id());
+    manager_->StartSession(client);
     EXPECT_EQ(nth == 1, manager_->start_initialization_is_called_);
     manager_->start_initialization_is_called_ = true;
   }
@@ -150,7 +152,7 @@ class MidiManagerTest : public ::testing::Test {
 
 TEST_F(MidiManagerTest, StartAndEndSession) {
   scoped_ptr<FakeMidiManagerClient> client;
-  client.reset(new FakeMidiManagerClient(0));
+  client.reset(new FakeMidiManagerClient);
 
   StartTheFirstSession(client.get());
   CompleteInitialization(MIDI_OK);
@@ -160,7 +162,7 @@ TEST_F(MidiManagerTest, StartAndEndSession) {
 
 TEST_F(MidiManagerTest, StartAndEndSessionWithError) {
   scoped_ptr<FakeMidiManagerClient> client;
-  client.reset(new FakeMidiManagerClient(1));
+  client.reset(new FakeMidiManagerClient);
 
   StartTheFirstSession(client.get());
   CompleteInitialization(MIDI_INITIALIZATION_ERROR);
@@ -172,9 +174,9 @@ TEST_F(MidiManagerTest, StartMultipleSessions) {
   scoped_ptr<FakeMidiManagerClient> client1;
   scoped_ptr<FakeMidiManagerClient> client2;
   scoped_ptr<FakeMidiManagerClient> client3;
-  client1.reset(new FakeMidiManagerClient(0));
-  client2.reset(new FakeMidiManagerClient(1));
-  client3.reset(new FakeMidiManagerClient(1));
+  client1.reset(new FakeMidiManagerClient);
+  client2.reset(new FakeMidiManagerClient);
+  client3.reset(new FakeMidiManagerClient);
 
   StartTheFirstSession(client1.get());
   StartTheNthSession(client2.get(), 2);
@@ -196,16 +198,15 @@ TEST_F(MidiManagerTest, TooManyPendingSessions) {
   ScopedVector<FakeMidiManagerClient> many_existing_clients;
   many_existing_clients.resize(MidiManager::kMaxPendingClientCount);
   for (size_t i = 0; i < MidiManager::kMaxPendingClientCount; ++i) {
-    many_existing_clients[i] = new FakeMidiManagerClient(i);
+    many_existing_clients[i] = new FakeMidiManagerClient;
     StartTheNthSession(many_existing_clients[i], i + 1);
   }
 
   // Push the last client that should be rejected for too many pending requests.
   scoped_ptr<FakeMidiManagerClient> additional_client(
-      new FakeMidiManagerClient(MidiManager::kMaxPendingClientCount));
+      new FakeMidiManagerClient);
   manager_->start_initialization_is_called_ = false;
-  manager_->StartSession(additional_client.get(),
-                         additional_client->client_id());
+  manager_->StartSession(additional_client.get());
   EXPECT_FALSE(manager_->start_initialization_is_called_);
   EXPECT_EQ(MIDI_INITIALIZATION_ERROR, additional_client->result());
 
@@ -229,7 +230,7 @@ TEST_F(MidiManagerTest, AbortSession) {
   // A client starting a session can be destructed while an asynchronous
   // initialization is performed.
   scoped_ptr<FakeMidiManagerClient> client;
-  client.reset(new FakeMidiManagerClient(0));
+  client.reset(new FakeMidiManagerClient);
 
   StartTheFirstSession(client.get());
   EndSession(client.get(), 0, 0);
@@ -243,10 +244,10 @@ TEST_F(MidiManagerTest, AbortSession) {
 
 TEST_F(MidiManagerTest, CreateMidiManager) {
   scoped_ptr<FakeMidiManagerClient> client;
-  client.reset(new FakeMidiManagerClient(0));
+  client.reset(new FakeMidiManagerClient);
 
   scoped_ptr<MidiManager> manager(MidiManager::Create());
-  manager->StartSession(client.get(), client->client_id());
+  manager->StartSession(client.get());
 
   MidiResult result = client->WaitForResult();
   // This #ifdef needs to be identical to the one in media/midi/midi_manager.cc.