PPAPI: Force async callback invocation option.

ppapi/tests/test_transport.cc

 // Copyright (c) 2011 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 "ppapi/tests/test_transport.h"
 
 #include <stdlib.h>
 #include <string.h>
 
 #include <list>
@@ skipping 36 matching lines @@
 
   const std::list<std::vector<char> >& received() { return received_; }
   std::list<std::string> errors() { return errors_; }
 
  private:
   void Read() {
     while (true) {
       buffer_.resize(kReadBufferSize);
       int result = transport_->Recv(
           &buffer_[0], buffer_.size(),
-          callback_factory_.NewCallback(&StreamReader::OnReadFinished));
+          callback_factory_.NewOptionalCallback(&StreamReader::OnReadFinished));
       if (result > 0)
         DidFinishRead(result);
       else
         break;
     }
   }
 
   void OnReadFinished(int result) {
     DidFinishRead(result);
     if (result > 0)
@@ skipping 29 matching lines @@
 
 bool TestTransport::Init() {
   transport_interface_ = reinterpret_cast<PPB_Transport_Dev const*>(
       pp::Module::Get()->GetBrowserInterface(PPB_TRANSPORT_DEV_INTERFACE));
   return transport_interface_ && InitTestingInterface();
 }
 
 void TestTransport::RunTest() {
   RUN_TEST(Create);
   RUN_TEST(Connect);
-  RUN_TEST(SendDataUdp);
-  RUN_TEST(SendDataTcp);
+  RUN_ASYNC_TEST(SendDataUdp);
+  RUN_ASYNC_TEST(SendDataTcp);
   RUN_TEST(ConnectAndCloseUdp);
   RUN_TEST(ConnectAndCloseTcp);
 }
 
 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);
@@ skipping 72 matching lines @@
 
   std::map<int, std::vector<char> > sent_packets;
   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;
     }
     // Put packet index in the beginning.
     memcpy(&send_buffer[0], &i, sizeof(i));
 
-    TestCompletionCallback send_cb(instance_->pp_instance());
-    ASSERT_EQ(
-        transport2_->Send(&send_buffer[0], send_buffer.size(), send_cb),
-        static_cast<int>(send_buffer.size()));
+    TestCompletionCallback send_cb(instance_->pp_instance(), force_async_);
+    int32_t result = transport2_->Send(&send_buffer[0], send_buffer.size(),
+                                       send_cb);
+    if (force_async_) {
+      ASSERT_EQ(result, PP_OK_COMPLETIONPENDING);
+      ASSERT_EQ(send_cb.WaitForResult(), static_cast<int>(send_buffer.size()));
+    } else {
+      ASSERT_EQ(result, static_cast<int>(send_buffer.size()));
+    }
     sent_packets[i] = send_buffer;
   }
 
   // Limit waiting time.
   pp::Module::Get()->core()->CallOnMainThread(kUdpWaitTimeMs, done_cb);
   ASSERT_EQ(done_cb.WaitForResult(), PP_OK);
 
   ASSERT_TRUE(reader.errors().size() == 0);
   ASSERT_TRUE(reader.received().size() > 0);
   for (std::list<std::vector<char> >::const_iterator it =
@@ skipping 21 matching lines @@
   StreamReader reader(transport1_.get(), kTcpSendSize,
                       done_cb);
 
   std::vector<char> send_buffer(kTcpSendSize);
   for (size_t j = 0; j < send_buffer.size(); ++j) {
     send_buffer[j] = rand() % 256;
   }
 
   int pos = 0;
   while (pos < static_cast<int>(send_buffer.size())) {
-    TestCompletionCallback send_cb(instance_->pp_instance());
+    TestCompletionCallback send_cb(instance_->pp_instance(), force_async_);
     int result = transport2_->Send(
         &send_buffer[0] + pos, send_buffer.size() - pos, send_cb);
+    if (force_async_)
+      ASSERT_EQ(result, PP_OK_COMPLETIONPENDING);
     if (result == PP_OK_COMPLETIONPENDING)
       result = send_cb.WaitForResult();
     ASSERT_TRUE(result > 0);
     pos += result;
   }
 
   // Limit waiting time.
   pp::Module::Get()->core()->CallOnMainThread(kTimeoutMs, done_cb);
   ASSERT_EQ(done_cb.WaitForResult(), PP_OK);
 
@@ skipping 45 matching lines @@
   // 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();
 }