Implement PseudoTCP support in P2P Transport Pepper API.

BUG=None
TEST=Unittests

Review URL: http://codereview.chromium.org/6893101

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@83736 0039d316-1c4b-4281-b951-d872f2087c98

4 files changed, 100 insertions, 22 deletions

diff --git a/ppapi/tests/test_transport.cc b/ppapi/tests/test_transport.cc
index bcf9701..80f9475 100644
--- a/ppapi/tests/test_transport.cc
+++ b/ppapi/tests/test_transport.cc
@@ -22,7 +22,7 @@
 REGISTER_TEST_CASE(Transport);
 
 #define RUN_SUBTEST(function) { \
-    std::string result = function(); \
+    std::string result = function; \
     if (!result.empty()) \
       return result; \
   }
@@ -96,13 +96,15 @@ bool TestTransport::Init() {
 void TestTransport::RunTest() {
   RUN_TEST(Create);
   RUN_TEST(Connect);
-  RUN_TEST(SendData);
-  RUN_TEST(ConnectAndClose);
+  RUN_TEST(SendDataUdp);
+  RUN_TEST(SendDataTcp);
+  RUN_TEST(ConnectAndCloseUdp);
+  RUN_TEST(ConnectAndCloseTcp);
 }
 
-std::string TestTransport::InitTargets() {
-  transport1_.reset(new pp::Transport_Dev(instance_, kTestChannelName, ""));
-  transport2_.reset(new pp::Transport_Dev(instance_, kTestChannelName, ""));
+std::string TestTransport::InitTargets(const char* proto) {
+  transport1_.reset(new pp::Transport_Dev(instance_, kTestChannelName, proto));
+  transport2_.reset(new pp::Transport_Dev(instance_, kTestChannelName, proto));
 
   ASSERT_TRUE(transport1_.get() != NULL);
   ASSERT_TRUE(transport2_.get() != NULL);
@@ -149,7 +151,7 @@ std::string TestTransport::Clean() {
 }
 
 std::string TestTransport::TestCreate() {
-  RUN_SUBTEST(InitTargets);
+  RUN_SUBTEST(InitTargets("udp"));
 
   Clean();
 
@@ -157,17 +159,17 @@ std::string TestTransport::TestCreate() {
 }
 
 std::string TestTransport::TestConnect() {
-  RUN_SUBTEST(InitTargets);
-  RUN_SUBTEST(Connect);
+  RUN_SUBTEST(InitTargets("udp"));
+  RUN_SUBTEST(Connect());
 
   Clean();
 
   PASS();
 }
 
-std::string TestTransport::TestSendData() {
-  RUN_SUBTEST(InitTargets);
-  RUN_SUBTEST(Connect);
+std::string TestTransport::TestSendDataUdp() {
+  RUN_SUBTEST(InitTargets("udp"));
+  RUN_SUBTEST(Connect());
 
   StreamReader reader(transport1_.get());
 
@@ -206,9 +208,72 @@ std::string TestTransport::TestSendData() {
   PASS();
 }
 
-std::string TestTransport::TestConnectAndClose() {
-  RUN_SUBTEST(InitTargets);
-  RUN_SUBTEST(Connect);
+std::string TestTransport::TestSendDataTcp() {
+  RUN_SUBTEST(InitTargets("tcp"));
+  RUN_SUBTEST(Connect());
+
+  StreamReader reader(transport1_.get());
+
+  std::vector<char> sent_data;
+  for (int i = 0; i < kNumPackets; ++i) {
+    std::vector<char> send_buffer(kSendBufferSize);
+    for (size_t j = 0; j < send_buffer.size(); ++j) {
+      send_buffer[j] = rand() % 256;
+    }
+
+    TestCompletionCallback send_cb(instance_->pp_instance());
+    int result = transport2_->Send(&send_buffer[0], send_buffer.size(),
+                                   send_cb);
+    if (result == PP_OK_COMPLETIONPENDING)
+      result = send_cb.WaitForResult();
+    ASSERT_TRUE(result > 0);
+    sent_data.insert(sent_data.end(), send_buffer.begin(),
+                     send_buffer.begin() + result);
+  }
+
+  // Wait for 1 second.
+  TestCompletionCallback wait_cb(instance_->pp_instance());
+  pp::Module::Get()->core()->CallOnMainThread(1000, wait_cb);
+  ASSERT_EQ(wait_cb.WaitForResult(), PP_OK);
+
+  ASSERT_TRUE(reader.errors().size() == 0);
+
+  std::vector<char> received_data;
+  for (std::list<std::vector<char> >::const_iterator it =
+           reader.received().begin(); it != reader.received().end(); ++it) {
+    received_data.insert(received_data.end(), it->begin(), it->end());
+  }
+  ASSERT_EQ(sent_data, received_data);
+
+  Clean();
+
+  PASS();
+}
+
+std::string TestTransport::TestConnectAndCloseUdp() {
+  RUN_SUBTEST(InitTargets("udp"));
+  RUN_SUBTEST(Connect());
+
+  std::vector<char> recv_buffer(kReadBufferSize);
+  TestCompletionCallback recv_cb(instance_->pp_instance());
+  ASSERT_EQ(
+      transport1_->Recv(&recv_buffer[0], recv_buffer.size(), recv_cb),
+      PP_OK_COMPLETIONPENDING);
+
+  // Close the transport and verify that callback is aborted.
+  ASSERT_EQ(transport1_->Close(), PP_OK);
+
+  ASSERT_EQ(recv_cb.run_count(), 1);
+  ASSERT_EQ(recv_cb.result(), PP_ERROR_ABORTED);
+
+  Clean();
+
+  PASS();
+}
+
+std::string TestTransport::TestConnectAndCloseTcp() {
+  RUN_SUBTEST(InitTargets("tcp"));
+  RUN_SUBTEST(Connect());
 
   std::vector<char> recv_buffer(kReadBufferSize);
   TestCompletionCallback recv_cb(instance_->pp_instance());
diff --git a/ppapi/tests/test_transport.h b/ppapi/tests/test_transport.h
index f883b6a..2f3a8147 100644
--- a/ppapi/tests/test_transport.h
+++ b/ppapi/tests/test_transport.h
@@ -25,14 +25,16 @@ class TestTransport : public TestCase {
   virtual void RunTest();
 
  private:
-  std::string InitTargets();
+  std::string InitTargets(const char* proto);
   std::string Connect();
   std::string Clean();
 
   std::string TestCreate();
   std::string TestConnect();
-  std::string TestSendData();
-  std::string TestConnectAndClose();
+  std::string TestSendDataTcp();
+  std::string TestSendDataUdp();
+  std::string TestConnectAndCloseTcp();
+  std::string TestConnectAndCloseUdp();
 
   // Used by the tests that access the C API directly.
   const PPB_Transport_Dev* transport_interface_;
diff --git a/ppapi/tests/test_utils.cc b/ppapi/tests/test_utils.cc
index 622c758..7e0a351 100644
--- a/ppapi/tests/test_utils.cc
+++ b/ppapi/tests/test_utils.cc
@@ -27,16 +27,20 @@ std::string ReportError(const char* method, int32_t error) {
 }
 
 TestCompletionCallback::TestCompletionCallback(PP_Instance instance)
-    : result_(PP_OK_COMPLETIONPENDING),
+    : have_result_(false),
+      result_(PP_OK_COMPLETIONPENDING),
       post_quit_task_(false),
       run_count_(0),
       instance_(instance) {
 }
 
 int32_t TestCompletionCallback::WaitForResult() {
-  result_ = PP_OK_COMPLETIONPENDING;  // Reset
-  post_quit_task_ = true;
-  GetTestingInterface()->RunMessageLoop(instance_);
+  if (!have_result_) {
+    result_ = PP_OK_COMPLETIONPENDING;  // Reset
+    post_quit_task_ = true;
+    GetTestingInterface()->RunMessageLoop(instance_);
+  }
+  have_result_ = false;
   return result_;
 }
 
@@ -50,6 +54,7 @@ void TestCompletionCallback::Handler(void* user_data, int32_t result) {
   TestCompletionCallback* callback =
       static_cast<TestCompletionCallback*>(user_data);
   callback->result_ = result;
+  callback->have_result_ = true;
   callback->run_count_++;
   if (callback->post_quit_task_) {
     callback->post_quit_task_ = false;
diff --git a/ppapi/tests/test_utils.h b/ppapi/tests/test_utils.h
index b71cc05..721a048 100644
--- a/ppapi/tests/test_utils.h
+++ b/ppapi/tests/test_utils.h
@@ -19,6 +19,11 @@ class TestCompletionCallback {
  public:
   TestCompletionCallback(PP_Instance instance);
 
+  // Waits for the callback to be called and returns the
+  // result. Returns immediately if the callback was previously called
+  // and the result wasn't returned (i.e. each result value received
+  // by the callback is returned by WaitForResult() once and only
+  // once).
   int32_t WaitForResult();
 
   operator pp::CompletionCallback() const;
@@ -31,6 +36,7 @@ class TestCompletionCallback {
  private:
   static void Handler(void* user_data, int32_t result);
 
+  bool have_result_;
   int32_t result_;
   bool post_quit_task_;
   unsigned run_count_;