Update PPAPI IDL generator to define versioned structs, and unversioned typedef.

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"
@@ skipping 12 matching lines @@
 const int kRefsToAdd = 20;
 }  // namespace
 
 namespace ppapi {
 namespace proxy {
 
 class PPB_VarTest : public PluginProxyTest {
  public:
   PPB_VarTest()
       : test_strings_(kNumStrings), vars_(kNumStrings),
-        ppb_var_(ppapi::PPB_Var_Shared::GetVarInterface()) {
+        ppb_var_(ppapi::PPB_Var_Shared::GetVarInterface1_1()) {
     // 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_;
 };
 
@@ skipping 51 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::PPB_Var_Shared::GetVarInterface();
+    const PPB_Var* ppb_var = ppapi::PPB_Var_Shared::GetVarInterface1_1();
     for (size_t i = 0; i < size_; ++i) {
       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::PPB_Var_Shared::GetVarInterface();
+    const PPB_Var* ppb_var = ppapi::PPB_Var_Shared::GetVarInterface1_1();
     // 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::PPB_Var_Shared::GetVarInterface();
+    const PPB_Var* ppb_var = ppapi::PPB_Var_Shared::GetVarInterface1_1();
     for (size_t i = 0; i < kNumStrings; ++i) {
       ppb_var->Release(vars_[i]);
     }
   }
  private:
   std::vector<PP_Var> vars_;
 };
 
 }  // namespace
 
@@ skipping 69 matching lines @@
   for (size_t i = 0; i < kNumStrings; ++i) {
     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
-