Remove PP_Module from parameters for PPB_Var.VarFromUtf8.

ppapi/proxy/ppb_var_unittest.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 <string>
 #include <vector>
 
 #include "base/string_number_conversions.h"
 #include "base/threading/platform_thread.h"
 #include "ppapi/c/pp_var.h"
 #include "ppapi/c/ppb_var.h"
 #include "ppapi/proxy/ppapi_proxy_test.h"
-#include "ppapi/proxy/ppb_var_proxy.h"
+#include "ppapi/shared_impl/ppb_var_impl.h"
 
 namespace {
 std::string VarToString(const PP_Var& var, const PPB_Var* ppb_var) {
   uint32_t len = 0;
   const char* utf8 = ppb_var->VarToUtf8(var, &len);
   return std::string(utf8, len);
 }
 const size_t kNumStrings = 100;
 const size_t kNumThreads = 20;
 const int kRefsToAdd = 20;
 }  // namespace
 
 namespace ppapi {
 namespace proxy {
 
 class PPB_VarTest : public PluginProxyTest {
  public:
   PPB_VarTest()
       : test_strings_(kNumStrings), vars_(kNumStrings),
-        ppb_var_(GetPPB_Var_Interface()) {
+        ppb_var_(ppapi::PPB_Var_Impl::GetVarInterface()) {
     // Set the value of test_strings_[i] to "i".
     for (size_t i = 0; i < kNumStrings; ++i)
       test_strings_[i] = base::IntToString(i);
   }
  protected:
   std::vector<std::string> test_strings_;
   std::vector<PP_Var> vars_;
   const PPB_Var* ppb_var_;
 };
 
 // Test basic String operations.
 TEST_F(PPB_VarTest, Strings) {
   for (size_t i = 0; i < kNumStrings; ++i) {
-    vars_[i] = ppb_var_->VarFromUtf8(pp_module(),
-                                   test_strings_[i].c_str(),
-                                   test_strings_[i].length());
+    vars_[i] = ppb_var_->VarFromUtf8(test_strings_[i].c_str(),
+                                     test_strings_[i].length());
     EXPECT_EQ(test_strings_[i], VarToString(vars_[i], ppb_var_));
   }
   // At this point, they should each have a ref count of 1. Add some more.
   for (int ref = 0; ref < kRefsToAdd; ++ref) {
     for (size_t i = 0; i < kNumStrings; ++i) {
       ppb_var_->AddRef(vars_[i]);
       // Make sure the string is still there with the right value.
       EXPECT_EQ(test_strings_[i], VarToString(vars_[i], ppb_var_));
     }
   }
@@ skipping 36 matching lines @@
   // For each |strings_in[i]|, we will set |vars[i]| using that value. Then we
   // read the var back out to |strings_out[i]|.
   CreateVarThreadDelegate(PP_Module pp_module, const std::string* strings_in,
                           PP_Var* vars_out, std::string* strings_out,
                           size_t size)
       : pp_module_(pp_module), strings_in_(strings_in), vars_out_(vars_out),
         strings_out_(strings_out), size_(size) {
   }
   virtual ~CreateVarThreadDelegate() {}
   virtual void ThreadMain() {
-    const PPB_Var* ppb_var = ppapi::proxy::GetPPB_Var_Interface();
+    const PPB_Var* ppb_var = ppapi::PPB_Var_Impl::GetVarInterface();
     for (size_t i = 0; i < size_; ++i) {
-      vars_out_[i] = ppb_var->VarFromUtf8(pp_module_,
-                                          strings_in_[i].c_str(),
+      vars_out_[i] = ppb_var->VarFromUtf8(strings_in_[i].c_str(),
                                           strings_in_[i].length());
       strings_out_[i] = VarToString(vars_out_[i], ppb_var);
     }
   }
  private:
   PP_Module pp_module_;
   const std::string* strings_in_;
   PP_Var* vars_out_;
   std::string* strings_out_;
   size_t size_;
 };
 
 // A thread that will increment and decrement the reference count of every var
 // multiple times.
 class ChangeRefVarThreadDelegate : public base::PlatformThread::Delegate {
  public:
   ChangeRefVarThreadDelegate(const std::vector<PP_Var>& vars) : vars_(vars) {
   }
   virtual ~ChangeRefVarThreadDelegate() {}
   virtual void ThreadMain() {
-    const PPB_Var* ppb_var = ppapi::proxy::GetPPB_Var_Interface();
+    const PPB_Var* ppb_var = ppapi::PPB_Var_Impl::GetVarInterface();
     // Increment and decrement the reference count for each var kRefsToAdd
     // times. Note that we always AddRef once before doing the matching Release,
     // to ensure that we never accidentally release the last reference.
     for (int ref = 0; ref < kRefsToAdd; ++ref) {
       for (size_t i = 0; i < kNumStrings; ++i) {
         ppb_var->AddRef(vars_[i]);
         ppb_var->Release(vars_[i]);
       }
     }
     // Now add 1 ref to each Var. The net result is that all Vars will have a
     // ref-count of (kNumThreads + 1) after this. That will allow us to have all
     // threads release all vars later.
     for (size_t i = 0; i < kNumStrings; ++i) {
       ppb_var->AddRef(vars_[i]);
     }
   }
  private:
   std::vector<PP_Var> vars_;
 };
 
 // A thread that will decrement the reference count of every var once.
 class RemoveRefVarThreadDelegate : public base::PlatformThread::Delegate {
  public:
   RemoveRefVarThreadDelegate(const std::vector<PP_Var>& vars) : vars_(vars) {
   }
   virtual ~RemoveRefVarThreadDelegate() {}
   virtual void ThreadMain() {
-    const PPB_Var* ppb_var = ppapi::proxy::GetPPB_Var_Interface();
+    const PPB_Var* ppb_var = ppapi::PPB_Var_Impl::GetVarInterface();
     for (size_t i = 0; i < kNumStrings; ++i) {
       ppb_var->Release(vars_[i]);
     }
   }
  private:
   std::vector<PP_Var> vars_;
 };
 
 }  // namespace
 
@@ skipping 70 matching lines @@
     uint32_t len = 10;
     const char* utf8 = ppb_var_->VarToUtf8(vars_[i], &len);
     EXPECT_EQ(NULL, utf8);
     EXPECT_EQ(0u, len);
   }
 }
 
 }  // namespace proxy
 }  // namespace ppapi