Home | History | Annotate | Download | only in tests 
      1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
      2 // Use of this source code is governed by a BSD-style license that can be
      3 // found in the LICENSE file.
      4 
      5 #include "ppapi/tests/test_utils.h"
      6 
      7 #include <stdio.h>
      8 #include <stdlib.h>
      9 #include <string.h>
     10 #if defined(_MSC_VER)
     11 #include <windows.h>
     12 #else
     13 #include <unistd.h>
     14 #endif
     15 
     16 #include "ppapi/c/pp_errors.h"
     17 #include "ppapi/cpp/instance_handle.h"
     18 #include "ppapi/cpp/module.h"
     19 #include "ppapi/cpp/net_address.h"
     20 #include "ppapi/cpp/private/host_resolver_private.h"
     21 #include "ppapi/cpp/private/net_address_private.h"
     22 #include "ppapi/cpp/var.h"
     23 
     24 namespace {
     25 
     26 bool IsBigEndian() {
     27   union {
     28     uint32_t integer32;
     29     uint8_t integer8[4];
     30   } data = { 0x01020304 };
     31 
     32   return data.integer8[0] == 1;
     33 }
     34 
     35 }  // namespace
     36 
     37 const int kActionTimeoutMs = 10000;
     38 
     39 const PPB_Testing_Private* GetTestingInterface() {
     40   static const PPB_Testing_Private* g_testing_interface =
     41       static_cast<const PPB_Testing_Private*>(
     42           pp::Module::Get()->GetBrowserInterface(
     43               PPB_TESTING_PRIVATE_INTERFACE));
     44   return g_testing_interface;
     45 }
     46 
     47 std::string ReportError(const char* method, int32_t error) {
     48   char error_as_string[12];
     49   sprintf(error_as_string, "%d", static_cast<int>(error));
     50   std::string result = method + std::string(" failed with error: ") +
     51       error_as_string;
     52   return result;
     53 }
     54 
     55 void PlatformSleep(int duration_ms) {
     56 #if defined(_MSC_VER)
     57   ::Sleep(duration_ms);
     58 #else
     59   usleep(duration_ms * 1000);
     60 #endif
     61 }
     62 
     63 bool GetLocalHostPort(PP_Instance instance, std::string* host, uint16_t* port) {
     64   if (!host || !port)
     65     return false;
     66 
     67   const PPB_Testing_Private* testing = GetTestingInterface();
     68   if (!testing)
     69     return false;
     70 
     71   PP_URLComponents_Dev components;
     72   pp::Var pp_url(pp::PASS_REF,
     73                  testing->GetDocumentURL(instance, &components));
     74   if (!pp_url.is_string())
     75     return false;
     76   std::string url = pp_url.AsString();
     77 
     78   if (components.host.len < 0)
     79     return false;
     80   host->assign(url.substr(components.host.begin, components.host.len));
     81 
     82   if (components.port.len <= 0)
     83     return false;
     84 
     85   int i = atoi(url.substr(components.port.begin, components.port.len).c_str());
     86   if (i < 0 || i > 65535)
     87     return false;
     88   *port = static_cast<uint16_t>(i);
     89 
     90   return true;
     91 }
     92 
     93 uint16_t ConvertFromNetEndian16(uint16_t x) {
     94   if (IsBigEndian())
     95     return x;
     96   else
     97     return (x << 8) | (x >> 8);
     98 }
     99 
    100 uint16_t ConvertToNetEndian16(uint16_t x) {
    101   if (IsBigEndian())
    102     return x;
    103   else
    104     return (x << 8) | (x >> 8);
    105 }
    106 
    107 bool EqualNetAddress(const pp::NetAddress& addr1, const pp::NetAddress& addr2) {
    108   if (addr1.GetFamily() == PP_NETADDRESS_FAMILY_UNSPECIFIED ||
    109       addr2.GetFamily() == PP_NETADDRESS_FAMILY_UNSPECIFIED) {
    110     return false;
    111   }
    112 
    113   if (addr1.GetFamily() == PP_NETADDRESS_FAMILY_IPV4) {
    114     PP_NetAddress_IPv4 ipv4_addr1, ipv4_addr2;
    115     if (!addr1.DescribeAsIPv4Address(&ipv4_addr1) ||
    116         !addr2.DescribeAsIPv4Address(&ipv4_addr2)) {
    117       return false;
    118     }
    119 
    120     return ipv4_addr1.port == ipv4_addr2.port &&
    121            !memcmp(ipv4_addr1.addr, ipv4_addr2.addr, sizeof(ipv4_addr1.addr));
    122   } else {
    123     PP_NetAddress_IPv6 ipv6_addr1, ipv6_addr2;
    124     if (!addr1.DescribeAsIPv6Address(&ipv6_addr1) ||
    125         !addr2.DescribeAsIPv6Address(&ipv6_addr2)) {
    126       return false;
    127     }
    128 
    129     return ipv6_addr1.port == ipv6_addr2.port &&
    130            !memcmp(ipv6_addr1.addr, ipv6_addr2.addr, sizeof(ipv6_addr1.addr));
    131   }
    132 }
    133 
    134 bool ResolveHost(PP_Instance instance,
    135                  const std::string& host,
    136                  uint16_t port,
    137                  pp::NetAddress* addr) {
    138   // TODO(yzshen): Change to use the public host resolver once it is supported.
    139   pp::InstanceHandle instance_handle(instance);
    140   pp::HostResolverPrivate host_resolver(instance_handle);
    141   PP_HostResolver_Private_Hint hint =
    142       { PP_NETADDRESSFAMILY_PRIVATE_UNSPECIFIED, 0 };
    143 
    144   TestCompletionCallback callback(instance);
    145   callback.WaitForResult(
    146       host_resolver.Resolve(host, port, hint, callback.GetCallback()));
    147 
    148   PP_NetAddress_Private addr_private;
    149   if (callback.result() != PP_OK || host_resolver.GetSize() == 0 ||
    150       !host_resolver.GetNetAddress(0, &addr_private)) {
    151     return false;
    152   }
    153 
    154   switch (pp::NetAddressPrivate::GetFamily(addr_private)) {
    155     case PP_NETADDRESSFAMILY_PRIVATE_IPV4: {
    156       PP_NetAddress_IPv4 ipv4_addr;
    157       ipv4_addr.port = ConvertToNetEndian16(
    158           pp::NetAddressPrivate::GetPort(addr_private));
    159       if (!pp::NetAddressPrivate::GetAddress(addr_private, ipv4_addr.addr,
    160                                              sizeof(ipv4_addr.addr))) {
    161         return false;
    162       }
    163       *addr = pp::NetAddress(instance_handle, ipv4_addr);
    164       return true;
    165     }
    166     case PP_NETADDRESSFAMILY_PRIVATE_IPV6: {
    167       PP_NetAddress_IPv6 ipv6_addr;
    168       ipv6_addr.port = ConvertToNetEndian16(
    169           pp::NetAddressPrivate::GetPort(addr_private));
    170       if (!pp::NetAddressPrivate::GetAddress(addr_private, ipv6_addr.addr,
    171                                              sizeof(ipv6_addr.addr))) {
    172         return false;
    173       }
    174       *addr = pp::NetAddress(instance_handle, ipv6_addr);
    175       return true;
    176     }
    177     default: {
    178       return false;
    179     }
    180   }
    181 }
    182 
    183 bool ReplacePort(PP_Instance instance,
    184                  const pp::NetAddress& input_addr,
    185                  uint16_t port,
    186                  pp::NetAddress* output_addr) {
    187   switch (input_addr.GetFamily()) {
    188     case PP_NETADDRESS_FAMILY_IPV4: {
    189       PP_NetAddress_IPv4 ipv4_addr;
    190       if (!input_addr.DescribeAsIPv4Address(&ipv4_addr))
    191         return false;
    192       ipv4_addr.port = ConvertToNetEndian16(port);
    193       *output_addr = pp::NetAddress(pp::InstanceHandle(instance), ipv4_addr);
    194       return true;
    195     }
    196     case PP_NETADDRESS_FAMILY_IPV6: {
    197       PP_NetAddress_IPv6 ipv6_addr;
    198       if (!input_addr.DescribeAsIPv6Address(&ipv6_addr))
    199         return false;
    200       ipv6_addr.port = ConvertToNetEndian16(port);
    201       *output_addr = pp::NetAddress(pp::InstanceHandle(instance), ipv6_addr);
    202       return true;
    203     }
    204     default: {
    205       return false;
    206     }
    207   }
    208 }
    209 
    210 uint16_t GetPort(const pp::NetAddress& addr) {
    211   switch (addr.GetFamily()) {
    212     case PP_NETADDRESS_FAMILY_IPV4: {
    213       PP_NetAddress_IPv4 ipv4_addr;
    214       if (!addr.DescribeAsIPv4Address(&ipv4_addr))
    215         return 0;
    216       return ConvertFromNetEndian16(ipv4_addr.port);
    217     }
    218     case PP_NETADDRESS_FAMILY_IPV6: {
    219       PP_NetAddress_IPv6 ipv6_addr;
    220       if (!addr.DescribeAsIPv6Address(&ipv6_addr))
    221         return 0;
    222       return ConvertFromNetEndian16(ipv6_addr.port);
    223     }
    224     default: {
    225       return 0;
    226     }
    227   }
    228 }
    229 
    230 void NestedEvent::Wait() {
    231   PP_DCHECK(pp::Module::Get()->core()->IsMainThread());
    232   // Don't allow nesting more than once; it doesn't work with the code as-is,
    233   // and probably is a bad idea most of the time anyway.
    234   PP_DCHECK(!waiting_);
    235   if (signalled_)
    236     return;
    237   waiting_ = true;
    238   while (!signalled_)
    239     GetTestingInterface()->RunMessageLoop(instance_);
    240   waiting_ = false;
    241 }
    242 
    243 void NestedEvent::Signal() {
    244   if (pp::Module::Get()->core()->IsMainThread())
    245     SignalOnMainThread();
    246   else
    247     PostSignal(0);
    248 }
    249 
    250 void NestedEvent::PostSignal(int32_t wait_ms) {
    251   pp::Module::Get()->core()->CallOnMainThread(
    252       wait_ms,
    253       pp::CompletionCallback(&SignalThunk, this),
    254       0);
    255 }
    256 
    257 void NestedEvent::Reset() {
    258   PP_DCHECK(pp::Module::Get()->core()->IsMainThread());
    259   // It doesn't make sense to reset when we're still waiting.
    260   PP_DCHECK(!waiting_);
    261   signalled_ = false;
    262 }
    263 
    264 void NestedEvent::SignalOnMainThread() {
    265   PP_DCHECK(pp::Module::Get()->core()->IsMainThread());
    266   signalled_ = true;
    267   if (waiting_)
    268     GetTestingInterface()->QuitMessageLoop(instance_);
    269 }
    270 
    271 void NestedEvent::SignalThunk(void* event, int32_t /* result */) {
    272   static_cast<NestedEvent*>(event)->SignalOnMainThread();
    273 }
    274 
    275 TestCompletionCallback::TestCompletionCallback(PP_Instance instance)
    276     : wait_for_result_called_(false),
    277       have_result_(false),
    278       result_(PP_OK_COMPLETIONPENDING),
    279       // TODO(dmichael): The default should probably be PP_REQUIRED, but this is
    280       //                 what the tests currently expect.
    281       callback_type_(PP_OPTIONAL),
    282       post_quit_task_(false),
    283       instance_(instance),
    284       delegate_(NULL) {
    285 }
    286 
    287 TestCompletionCallback::TestCompletionCallback(PP_Instance instance,
    288                                                bool force_async)
    289     : wait_for_result_called_(false),
    290       have_result_(false),
    291       result_(PP_OK_COMPLETIONPENDING),
    292       callback_type_(force_async ? PP_REQUIRED : PP_OPTIONAL),
    293       post_quit_task_(false),
    294       instance_(instance),
    295       delegate_(NULL) {
    296 }
    297 
    298 TestCompletionCallback::TestCompletionCallback(PP_Instance instance,
    299                                                CallbackType callback_type)
    300     : wait_for_result_called_(false),
    301       have_result_(false),
    302       result_(PP_OK_COMPLETIONPENDING),
    303       callback_type_(callback_type),
    304       post_quit_task_(false),
    305       instance_(instance),
    306       delegate_(NULL) {
    307 }
    308 
    309 void TestCompletionCallback::WaitForResult(int32_t result) {
    310   PP_DCHECK(!wait_for_result_called_);
    311   wait_for_result_called_ = true;
    312   errors_.clear();
    313   if (result == PP_OK_COMPLETIONPENDING) {
    314     if (!have_result_) {
    315       post_quit_task_ = true;
    316       RunMessageLoop();
    317     }
    318     if (callback_type_ == PP_BLOCKING) {
    319       errors_.assign(
    320           ReportError("TestCompletionCallback: Call did not run synchronously "
    321                       "when passed a blocking completion callback!",
    322                       result_));
    323       return;
    324     }
    325   } else {
    326     result_ = result;
    327     have_result_ = true;
    328     if (callback_type_ == PP_REQUIRED) {
    329       errors_.assign(
    330           ReportError("TestCompletionCallback: Call ran synchronously when "
    331                       "passed a required completion callback!",
    332                       result_));
    333       return;
    334     }
    335   }
    336   PP_DCHECK(have_result_ == true);
    337 }
    338 
    339 void TestCompletionCallback::WaitForAbortResult(int32_t result) {
    340   WaitForResult(result);
    341   int32_t final_result = result_;
    342   if (result == PP_OK_COMPLETIONPENDING) {
    343     if (final_result != PP_ERROR_ABORTED) {
    344       errors_.assign(
    345           ReportError("TestCompletionCallback: Expected PP_ERROR_ABORTED or "
    346                       "PP_OK. Ran asynchronously.",
    347                       final_result));
    348       return;
    349     }
    350   } else if (result < PP_OK) {
    351     errors_.assign(
    352         ReportError("TestCompletionCallback: Expected PP_ERROR_ABORTED or "
    353                     "non-error response. Ran synchronously.",
    354                     result));
    355     return;
    356   }
    357 }
    358 
    359 pp::CompletionCallback TestCompletionCallback::GetCallback() {
    360   Reset();
    361   int32_t flags = 0;
    362   if (callback_type_ == PP_BLOCKING)
    363     return pp::CompletionCallback();
    364   else if (callback_type_ == PP_OPTIONAL)
    365     flags = PP_COMPLETIONCALLBACK_FLAG_OPTIONAL;
    366   target_loop_ = pp::MessageLoop::GetCurrent();
    367   return pp::CompletionCallback(&TestCompletionCallback::Handler,
    368                                 const_cast<TestCompletionCallback*>(this),
    369                                 flags);
    370 }
    371 
    372 void TestCompletionCallback::Reset() {
    373   wait_for_result_called_ = false;
    374   result_ = PP_OK_COMPLETIONPENDING;
    375   have_result_ = false;
    376   post_quit_task_ = false;
    377   delegate_ = NULL;
    378   errors_.clear();
    379 }
    380 
    381 // static
    382 void TestCompletionCallback::Handler(void* user_data, int32_t result) {
    383   TestCompletionCallback* callback =
    384       static_cast<TestCompletionCallback*>(user_data);
    385   // If this check fails, it means that the callback was invoked twice or that
    386   // the PPAPI call completed synchronously, but also ran the callback.
    387   PP_DCHECK(!callback->have_result_);
    388   callback->result_ = result;
    389   callback->have_result_ = true;
    390   if (callback->delegate_)
    391     callback->delegate_->OnCallback(user_data, result);
    392   if (callback->post_quit_task_) {
    393     callback->post_quit_task_ = false;
    394     callback->QuitMessageLoop();
    395   }
    396   if (callback->target_loop_ != pp::MessageLoop::GetCurrent()) {
    397     // Note, in-process, loop_ and GetCurrent() will both be NULL, so should
    398     // still be equal.
    399     callback->errors_.assign(
    400         ReportError("TestCompletionCallback: Callback ran on the wrong message "
    401                     "loop!",
    402                     result));
    403   }
    404 }
    405 
    406 void TestCompletionCallback::RunMessageLoop() {
    407   pp::MessageLoop loop(pp::MessageLoop::GetCurrent());
    408   // If we don't have a message loop, we're probably running in process, where
    409   // PPB_MessageLoop is not supported. Just use the Testing message loop.
    410   if (loop.is_null() || loop == pp::MessageLoop::GetForMainThread())
    411     GetTestingInterface()->RunMessageLoop(instance_);
    412   else
    413     loop.Run();
    414 }
    415 
    416 void TestCompletionCallback::QuitMessageLoop() {
    417   pp::MessageLoop loop(pp::MessageLoop::GetCurrent());
    418   // If we don't have a message loop, we're probably running in process, where
    419   // PPB_MessageLoop is not supported. Just use the Testing message loop.
    420   if (loop.is_null() || loop == pp::MessageLoop::GetForMainThread()) {
    421     GetTestingInterface()->QuitMessageLoop(instance_);
    422   } else {
    423     const bool should_quit = false;
    424     loop.PostQuit(should_quit);
    425   }
    426 }
    427