src/ppapi/proxy/ppb_var_unittest.cc

   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 <string>
   6 #include <vector>
   7
   8 #include "base/strings/string_number_conversions.h"
   9 #include "base/threading/platform_thread.h"
  10 #include "ppapi/c/pp_var.h"
  11 #include "ppapi/c/ppb_var.h"
  12 #include "ppapi/proxy/ppapi_proxy_test.h"
  13 #include "ppapi/shared_impl/ppb_var_shared.h"
  14
  15 namespace {
  16 std::string VarToString(const PP_Var& var, const PPB_Var* ppb_var) {
  17   uint32_t len = 0;
  18   const char* utf8 = ppb_var->VarToUtf8(var, &len);
  19   return std::string(utf8, len);
  20 }
  21 const size_t kNumStrings = 100;
  22 const size_t kNumThreads = 20;
  23 const int kRefsToAdd = 20;
  24 }  // namespace
  25
  26 namespace ppapi {
  27 namespace proxy {
  28
  29 class PPB_VarTest : public PluginProxyTest {
  30  public:
  31   PPB_VarTest()
  32       : test_strings_(kNumStrings), vars_(kNumStrings),
  33         ppb_var_(ppapi::PPB_Var_Shared::GetVarInterface1_1()) {
  34     // Set the value of test_strings_[i] to "i".
  35     for (size_t i = 0; i < kNumStrings; ++i)
  36       test_strings_[i] = base::IntToString(i);
  37   }
  38  protected:
  39   std::vector<std::string> test_strings_;
  40   std::vector<PP_Var> vars_;
  41   const PPB_Var* ppb_var_;
  42 };
  43
  44 // Test basic String operations.
  45 TEST_F(PPB_VarTest, Strings) {
  46   for (size_t i = 0; i < kNumStrings; ++i) {
  47     vars_[i] = ppb_var_->VarFromUtf8(test_strings_[i].c_str(),
  48                                      test_strings_[i].length());
  49     EXPECT_EQ(test_strings_[i], VarToString(vars_[i], ppb_var_));
  50   }
  51   // At this point, they should each have a ref count of 1. Add some more.
  52   for (int ref = 0; ref < kRefsToAdd; ++ref) {
  53     for (size_t i = 0; i < kNumStrings; ++i) {
  54       ppb_var_->AddRef(vars_[i]);
  55       // Make sure the string is still there with the right value.
  56       EXPECT_EQ(test_strings_[i], VarToString(vars_[i], ppb_var_));
  57     }
  58   }
  59   for (int ref = 0; ref < kRefsToAdd; ++ref) {
  60     for (size_t i = 0; i < kNumStrings; ++i) {
  61       ppb_var_->Release(vars_[i]);
  62       // Make sure the string is still there with the right value.
  63       EXPECT_EQ(test_strings_[i], VarToString(vars_[i], ppb_var_));
  64     }
  65   }
  66   // Now remove the ref counts for each string and make sure they are gone.
  67   for (size_t i = 0; i < kNumStrings; ++i) {
  68     ppb_var_->Release(vars_[i]);
  69     uint32_t len = 10;
  70     const char* utf8 = ppb_var_->VarToUtf8(vars_[i], &len);
  71     EXPECT_EQ(NULL, utf8);
  72     EXPECT_EQ(0u, len);
  73   }
  74 }
  75
  76 // PPB_VarTest.Threads tests string operations accessed by multiple threads.
  77 namespace {
  78 // These three delegate classes which precede the test are for use with
  79 // PlatformThread. The test goes roughly like this:
  80 // 1) Spawn kNumThreads 'CreateVar' threads, giving each a roughly equal subset
  81 //    of test_strings_ to 'create'. Each 'CreateVar' thread also converts its
  82 //    set of vars back in to strings so that the main test thread can verify
  83 //    their values were correctly converted.
  84 // 2) Spawn kNumThreads 'ChangeRefVar' threads. Each of these threads will
  85 //    incremement & decrement the reference count of ALL vars kRefsToAdd times.
  86 //    Finally, each thread adds 1 ref count. This leaves each var with a ref-
  87 //    count of |kNumThreads + 1|. The main test thread removes a ref, leaving
  88 //    each var with a ref-count of |kNumThreads|.
  89 // 3) Spawn kNumThreads 'RemoveVar' threads. Each of these threads releases each
  90 //    var once. Once all the threads have finished, there should be no vars
  91 //    left.
  92 class CreateVarThreadDelegate : public base::PlatformThread::Delegate {
  93  public:
  94   // |strings_in|, |vars|, and |strings_out| are arrays, and size is their size.
  95   // For each |strings_in[i]|, we will set |vars[i]| using that value. Then we
  96   // read the var back out to |strings_out[i]|.
  97   CreateVarThreadDelegate(PP_Module pp_module, const std::string* strings_in,
  98                           PP_Var* vars_out, std::string* strings_out,
  99                           size_t size)
 100       : pp_module_(pp_module), strings_in_(strings_in), vars_out_(vars_out),
 101         strings_out_(strings_out), size_(size) {
 102   }
 103   virtual ~CreateVarThreadDelegate() {}
 104   virtual void ThreadMain() {
 105     const PPB_Var* ppb_var = ppapi::PPB_Var_Shared::GetVarInterface1_1();
 106     for (size_t i = 0; i < size_; ++i) {
 107       vars_out_[i] = ppb_var->VarFromUtf8(strings_in_[i].c_str(),
 108                                           strings_in_[i].length());
 109       strings_out_[i] = VarToString(vars_out_[i], ppb_var);
 110     }
 111   }
 112  private:
 113   PP_Module pp_module_;
 114   const std::string* strings_in_;
 115   PP_Var* vars_out_;
 116   std::string* strings_out_;
 117   size_t size_;
 118 };
 119
 120 // A thread that will increment and decrement the reference count of every var
 121 // multiple times.
 122 class ChangeRefVarThreadDelegate : public base::PlatformThread::Delegate {
 123  public:
 124   ChangeRefVarThreadDelegate(const std::vector<PP_Var>& vars) : vars_(vars) {
 125   }
 126   virtual ~ChangeRefVarThreadDelegate() {}
 127   virtual void ThreadMain() {
 128     const PPB_Var* ppb_var = ppapi::PPB_Var_Shared::GetVarInterface1_1();
 129     // Increment and decrement the reference count for each var kRefsToAdd
 130     // times. Note that we always AddRef once before doing the matching Release,
 131     // to ensure that we never accidentally release the last reference.
 132     for (int ref = 0; ref < kRefsToAdd; ++ref) {
 133       for (size_t i = 0; i < kNumStrings; ++i) {
 134         ppb_var->AddRef(vars_[i]);
 135         ppb_var->Release(vars_[i]);
 136       }
 137     }
 138     // Now add 1 ref to each Var. The net result is that all Vars will have a
 139     // ref-count of (kNumThreads + 1) after this. That will allow us to have all
 140     // threads release all vars later.
 141     for (size_t i = 0; i < kNumStrings; ++i) {
 142       ppb_var->AddRef(vars_[i]);
 143     }
 144   }
 145  private:
 146   std::vector<PP_Var> vars_;
 147 };
 148
 149 // A thread that will decrement the reference count of every var once.
 150 class RemoveRefVarThreadDelegate : public base::PlatformThread::Delegate {
 151  public:
 152   RemoveRefVarThreadDelegate(const std::vector<PP_Var>& vars) : vars_(vars) {
 153   }
 154   virtual ~RemoveRefVarThreadDelegate() {}
 155   virtual void ThreadMain() {
 156     const PPB_Var* ppb_var = ppapi::PPB_Var_Shared::GetVarInterface1_1();
 157     for (size_t i = 0; i < kNumStrings; ++i) {
 158       ppb_var->Release(vars_[i]);
 159     }
 160   }
 161  private:
 162   std::vector<PP_Var> vars_;
 163 };
 164
 165 }  // namespace
 166
 167 TEST_F(PPB_VarTest, Threads) {
 168   std::vector<base::PlatformThreadHandle> create_var_threads(kNumThreads);
 169   std::vector<CreateVarThreadDelegate> create_var_delegates;
 170   // The strings that the threads will re-extract from Vars (so we can check
 171   // that they match the original strings).
 172   std::vector<std::string> strings_out(kNumStrings);
 173   size_t strings_per_thread = kNumStrings/kNumThreads;
 174   // Give each thread an equal slice of strings to turn in to vars. (Except the
 175   // last thread may get fewer if kNumStrings is not evenly divisible by
 176   // kNumThreads).
 177   for (size_t slice_start= 0; slice_start < kNumStrings;
 178        slice_start += strings_per_thread) {
 179     create_var_delegates.push_back(
 180         CreateVarThreadDelegate(pp_module(),
 181                                 &test_strings_[slice_start],
 182                                 &vars_[slice_start],
 183                                 &strings_out[slice_start],
 184                                 std::min(strings_per_thread,
 185                                          kNumStrings - slice_start)));
 186   }
 187   // Now run then join all the threads.
 188   for (size_t i = 0; i < kNumThreads; ++i)
 189     base::PlatformThread::Create(0, &create_var_delegates[i],
 190                                  &create_var_threads[i]);
 191   for (size_t i = 0; i < kNumThreads; ++i)
 192     base::PlatformThread::Join(create_var_threads[i]);
 193   // Now check that the strings have the expected values.
 194   EXPECT_EQ(test_strings_, strings_out);
 195
 196   // Tinker with the reference counts in a multithreaded way.
 197   std::vector<base::PlatformThreadHandle> change_ref_var_threads(kNumThreads);
 198   std::vector<ChangeRefVarThreadDelegate> change_ref_var_delegates;
 199   for (size_t i = 0; i < kNumThreads; ++i)
 200     change_ref_var_delegates.push_back(ChangeRefVarThreadDelegate(vars_));
 201   for (size_t i = 0; i < kNumThreads; ++i) {
 202     base::PlatformThread::Create(0, &change_ref_var_delegates[i],
 203                                  &change_ref_var_threads[i]);
 204   }
 205   for (size_t i = 0; i < kNumThreads; ++i)
 206     base::PlatformThread::Join(change_ref_var_threads[i]);
 207
 208   // Now each var has a refcount of (kNumThreads + 1). Let's decrement each var
 209   // once so that every 'RemoveRef' thread (spawned below) owns 1 reference, and
 210   // when the last one removes a ref, the Var will be deleted.
 211   for (size_t i = 0; i < kNumStrings; ++i) {
 212     ppb_var_->Release(vars_[i]);
 213   }
 214
 215   // Check that all vars are still valid and have the values we expect.
 216   for (size_t i = 0; i < kNumStrings; ++i)
 217     EXPECT_EQ(test_strings_[i], VarToString(vars_[i], ppb_var_));
 218
 219   // Remove the last reference counts for all vars.
 220   std::vector<base::PlatformThreadHandle> remove_ref_var_threads(kNumThreads);
 221   std::vector<RemoveRefVarThreadDelegate> remove_ref_var_delegates;
 222   for (size_t i = 0; i < kNumThreads; ++i)
 223     remove_ref_var_delegates.push_back(RemoveRefVarThreadDelegate(vars_));
 224   for (size_t i = 0; i < kNumThreads; ++i) {
 225     base::PlatformThread::Create(0, &remove_ref_var_delegates[i],
 226                                  &remove_ref_var_threads[i]);
 227   }
 228   for (size_t i = 0; i < kNumThreads; ++i)
 229     base::PlatformThread::Join(remove_ref_var_threads[i]);
 230
 231   // All the vars should no longer represent valid strings.
 232   for (size_t i = 0; i < kNumStrings; ++i) {
 233     uint32_t len = 10;
 234     const char* utf8 = ppb_var_->VarToUtf8(vars_[i], &len);
 235     EXPECT_EQ(NULL, utf8);
 236     EXPECT_EQ(0u, len);
 237   }
 238 }
 239
 240 }  // namespace proxy
 241 }  // namespace ppapi