Add SetProperty() in the PPB_Transport_Dev interface.

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>
 #include <map>
 
 #include "ppapi/c/dev/ppb_testing_dev.h"
 #include "ppapi/c/pp_errors.h"
 #include "ppapi/cpp/completion_callback.h"
+#include "ppapi/cpp/dev/transport_dev.h"
 #include "ppapi/cpp/instance.h"
 #include "ppapi/cpp/module.h"
-#include "ppapi/cpp/dev/transport_dev.h"
+#include "ppapi/cpp/var.h"
 #include "ppapi/tests/test_utils.h"
 #include "ppapi/tests/testing_instance.h"
 
 REGISTER_TEST_CASE(Transport);
 
 #define RUN_SUBTEST(function) { \
     std::string result = function; \
     if (!result.empty()) \
       return result; \
   }
@@ skipping 67 matching lines @@
 }  // namespace
 
 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_FORCEASYNC(SendDataUdp);
-  RUN_TEST(SendDataTcp);
-  RUN_TEST(ConnectAndCloseUdp);
-  RUN_TEST(ConnectAndCloseTcp);
+  RUN_TEST_FORCEASYNC_AND_NOT(Connect);
+  RUN_TEST(SetProperty);
+  RUN_TEST_FORCEASYNC_AND_NOT(SendDataUdp);
+  RUN_TEST_FORCEASYNC_AND_NOT(SendDataTcp);
+  RUN_TEST_FORCEASYNC_AND_NOT(ConnectAndCloseUdp);
+  RUN_TEST_FORCEASYNC_AND_NOT(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);
 
   PASS();
@@ skipping 38 matching lines @@
 }
 
 std::string TestTransport::TestCreate() {
   RUN_SUBTEST(InitTargets("udp"));
 
   Clean();
 
   PASS();
 }
 
+std::string TestTransport::TestSetProperty() {
+  RUN_SUBTEST(InitTargets("tcp"));
+
+  // Try settings STUN and Relay properties.
+  ASSERT_EQ(transport1_->SetProperty(
+      PP_TRANSPORTPROPERTY_STUN_SERVER,
+      pp::Var("stun.example.com:19302")), PP_OK);
+
+  ASSERT_EQ(transport1_->SetProperty(
+      PP_TRANSPORTPROPERTY_RELAY_SERVER,
+      pp::Var("ralay.example.com:80")), PP_OK);
+
+  ASSERT_EQ(transport1_->SetProperty(
+      PP_TRANSPORTPROPERTY_RELAY_TOKEN,
+      pp::Var("INVALID_TOKEN")), PP_OK);
+
+  // Try changing TCP window size.
+  ASSERT_EQ(transport1_->SetProperty(PP_TRANSPORTPROPERTY_TCP_RECEIVE_WINDOW,
+                                     pp::Var(65536)), PP_OK);
+  ASSERT_EQ(transport1_->SetProperty(PP_TRANSPORTPROPERTY_TCP_RECEIVE_WINDOW,
+                                     pp::Var(10000000)), PP_ERROR_BADARGUMENT);
+
+  ASSERT_EQ(transport1_->SetProperty(PP_TRANSPORTPROPERTY_TCP_SEND_WINDOW,
+                                     pp::Var(65536)), PP_OK);
+  ASSERT_EQ(transport1_->SetProperty(PP_TRANSPORTPROPERTY_TCP_SEND_WINDOW,
+                                     pp::Var(10000000)), PP_ERROR_BADARGUMENT);
+
+  TestCompletionCallback connect_cb(instance_->pp_instance());
+  ASSERT_EQ(transport1_->Connect(connect_cb), PP_OK_COMPLETIONPENDING);
+
+  // SetProperty() should fail after we've connected.
+  ASSERT_EQ(transport1_->SetProperty(
+      PP_TRANSPORTPROPERTY_STUN_SERVER,
+      pp::Var("stun.example.com:31323")), PP_ERROR_FAILED);
+
+  Clean();
+  ASSERT_EQ(connect_cb.WaitForResult(), PP_ERROR_ABORTED);
+
+  PASS();
+}
+
 std::string TestTransport::TestConnect() {
   RUN_SUBTEST(InitTargets("udp"));
   RUN_SUBTEST(Connect());
 
   Clean();
 
   PASS();
 }
 
 // Creating datagram connection and try sending data over it. Verify
@@ skipping 25 matching lines @@
     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);
+  TestCompletionCallback timeout_cb(instance_->pp_instance());
+  pp::Module::Get()->core()->CallOnMainThread(kUdpWaitTimeMs, timeout_cb);
+  ASSERT_EQ(timeout_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 =
            reader.received().begin(); it != reader.received().end(); ++it) {
     int index;
     memcpy(&index, &(*it)[0], sizeof(index));
     ASSERT_TRUE(sent_packets[index] == *it);
   }
 
   Clean();
 
   PASS();
 }
 
 // Creating reliable (TCP-like) connection and try sending data over
 // it. Verify that all data is received correctly.
 std::string TestTransport::TestSendDataTcp() {
   RUN_SUBTEST(InitTargets("tcp"));
   RUN_SUBTEST(Connect());
 
   const int kTcpSendSize = 100000;
-  const int kTimeoutMs = 20000;  // 20 seconds.
 
   TestCompletionCallback done_cb(instance_->pp_instance());
   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(), 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);
 
   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(send_buffer, received_data);
@@ skipping 37 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();
 }