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