Remove static initializers.

BUG=52915
TEST=no new functionality, passes ppapi_tests

Review URL: http://codereview.chromium.org/5797006

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@69732 0039d316-1c4b-4281-b951-d872f2087c98

1 files changed, 72 insertions, 65 deletions

diff --git a/ppapi/cpp/var.cc b/ppapi/cpp/var.cc
index a1f6730..58ff30a 100644
--- a/ppapi/cpp/var.cc
+++ b/ppapi/cpp/var.cc
@@ -22,9 +22,13 @@
 #  define snprintf sprintf_s
 #endif
 
+namespace pp {
+
 namespace {
 
-DeviceFuncs<PPB_Var_Deprecated> ppb_var_f(PPB_VAR_DEPRECATED_INTERFACE);
+template <> const char* interface_name<PPB_Var_Deprecated>() {
+  return PPB_VAR_DEPRECATED_INTERFACE;
+}
 
 // Technically you can call AddRef and Release on any Var, but it may involve
 // cross-process calls depending on the plugin. This is an optimization so we
@@ -35,8 +39,6 @@ inline bool NeedsRefcounting(const PP_Var& var) {
 
 }  // namespace
 
-namespace pp {
-
 using namespace deprecated;
 
 Var::Var() {
@@ -68,9 +70,10 @@ Var::Var(double d) {
 }
 
 Var::Var(const char* utf8_str) {
-  if (ppb_var_f) {
+  if (has_interface<PPB_Var_Deprecated>()) {
     uint32_t len = utf8_str ? static_cast<uint32_t>(strlen(utf8_str)) : 0;
-    var_ = ppb_var_f->VarFromUtf8(Module::Get()->pp_module(), utf8_str, len);
+    var_ = get_interface<PPB_Var_Deprecated>()->VarFromUtf8(
+        Module::Get()->pp_module(), utf8_str, len);
   } else {
     var_.type = PP_VARTYPE_NULL;
   }
@@ -78,10 +81,11 @@ Var::Var(const char* utf8_str) {
 }
 
 Var::Var(const std::string& utf8_str) {
-  if (ppb_var_f) {
-    var_ = ppb_var_f->VarFromUtf8(Module::Get()->pp_module(),
-                                  utf8_str.c_str(),
-                                  static_cast<uint32_t>(utf8_str.size()));
+  if (has_interface<PPB_Var_Deprecated>()) {
+    var_ = get_interface<PPB_Var_Deprecated>()->VarFromUtf8(
+        Module::Get()->pp_module(),
+        utf8_str.c_str(),
+        static_cast<uint32_t>(utf8_str.size()));
   } else {
     var_.type = PP_VARTYPE_NULL;
   }
@@ -89,9 +93,9 @@ Var::Var(const std::string& utf8_str) {
 }
 
 Var::Var(ScriptableObject* object) {
-  if (ppb_var_f) {
-    var_ = ppb_var_f->CreateObject(Module::Get()->pp_module(),
-                                   object->GetClass(), object);
+  if (has_interface<PPB_Var_Deprecated>()) {
+    var_ = get_interface<PPB_Var_Deprecated>()->CreateObject(
+        Module::Get()->pp_module(), object->GetClass(), object);
     needs_release_ = true;
   } else {
     var_.type = PP_VARTYPE_NULL;
@@ -102,9 +106,9 @@ Var::Var(ScriptableObject* object) {
 Var::Var(const Var& other) {
   var_ = other.var_;
   if (NeedsRefcounting(var_)) {
-    if (ppb_var_f) {
+    if (has_interface<PPB_Var_Deprecated>()) {
       needs_release_ = true;
-      ppb_var_f->AddRef(var_);
+      get_interface<PPB_Var_Deprecated>()->AddRef(var_);
     } else {
       var_.type = PP_VARTYPE_NULL;
       needs_release_ = false;
@@ -115,18 +119,18 @@ Var::Var(const Var& other) {
 }
 
 Var::~Var() {
-  if (needs_release_ && ppb_var_f)
-    ppb_var_f->Release(var_);
+  if (needs_release_ && has_interface<PPB_Var_Deprecated>())
+    get_interface<PPB_Var_Deprecated>()->Release(var_);
 }
 
 Var& Var::operator=(const Var& other) {
-  if (needs_release_ && ppb_var_f)
-    ppb_var_f->Release(var_);
+  if (needs_release_ && has_interface<PPB_Var_Deprecated>())
+    get_interface<PPB_Var_Deprecated>()->Release(var_);
   var_ = other.var_;
   if (NeedsRefcounting(var_)) {
-    if (ppb_var_f) {
+    if (has_interface<PPB_Var_Deprecated>()) {
       needs_release_ = true;
-      ppb_var_f->AddRef(var_);
+      get_interface<PPB_Var_Deprecated>()->AddRef(var_);
     } else {
       var_.type = PP_VARTYPE_NULL;
       needs_release_ = false;
@@ -194,19 +198,20 @@ std::string Var::AsString() const {
     return std::string();
   }
 
-  if (!ppb_var_f)
+  if (!has_interface<PPB_Var_Deprecated>())
     return std::string();
   uint32_t len;
-  const char* str = ppb_var_f->VarToUtf8(var_, &len);
+  const char* str = get_interface<PPB_Var_Deprecated>()->VarToUtf8(var_, &len);
   return std::string(str, len);
 }
 
 ScriptableObject* Var::AsScriptableObject() const {
   if (!is_object()) {
     PP_NOTREACHED();
-  } else if (ppb_var_f) {
+  } else if (has_interface<PPB_Var_Deprecated>()) {
     void* object = NULL;
-    if (ppb_var_f->IsInstanceOf(var_, ScriptableObject::GetClass(), &object)) {
+    if (get_interface<PPB_Var_Deprecated>()->IsInstanceOf(
+        var_, ScriptableObject::GetClass(), &object)) {
       return reinterpret_cast<ScriptableObject*>(object);
     }
   }
@@ -214,32 +219,34 @@ ScriptableObject* Var::AsScriptableObject() const {
 }
 
 bool Var::HasProperty(const Var& name, Var* exception) const {
-  if (!ppb_var_f)
+  if (!has_interface<PPB_Var_Deprecated>())
     return false;
-  return ppb_var_f->HasProperty(var_, name.var_, OutException(exception).get());
+  return get_interface<PPB_Var_Deprecated>()->HasProperty(
+      var_, name.var_, OutException(exception).get());
 }
 
 bool Var::HasMethod(const Var& name, Var* exception) const {
-  if (!ppb_var_f)
+  if (!has_interface<PPB_Var_Deprecated>())
     return false;
-  return ppb_var_f->HasMethod(var_, name.var_, OutException(exception).get());
+  return get_interface<PPB_Var_Deprecated>()->HasMethod(
+      var_, name.var_, OutException(exception).get());
 }
 
 Var Var::GetProperty(const Var& name, Var* exception) const {
-  if (!ppb_var_f)
+  if (!has_interface<PPB_Var_Deprecated>())
     return Var();
-  return Var(PassRef(), ppb_var_f->GetProperty(var_, name.var_,
-                                               OutException(exception).get()));
+  return Var(PassRef(), get_interface<PPB_Var_Deprecated>()->GetProperty(
+      var_, name.var_, OutException(exception).get()));
 }
 
 void Var::GetAllPropertyNames(std::vector<Var>* properties,
                               Var* exception) const {
-  if (!ppb_var_f)
+  if (!has_interface<PPB_Var_Deprecated>())
     return;
   PP_Var* props = NULL;
   uint32_t prop_count = 0;
-  ppb_var_f->GetAllPropertyNames(var_, &prop_count, &props,
-                                 OutException(exception).get());
+  get_interface<PPB_Var_Deprecated>()->GetAllPropertyNames(
+      var_, &prop_count, &props, OutException(exception).get());
   if (!prop_count)
     return;
   properties->resize(prop_count);
@@ -251,94 +258,94 @@ void Var::GetAllPropertyNames(std::vector<Var>* properties,
 }
 
 void Var::SetProperty(const Var& name, const Var& value, Var* exception) {
-  if (!ppb_var_f)
+  if (!has_interface<PPB_Var_Deprecated>())
     return;
-  ppb_var_f->SetProperty(var_, name.var_, value.var_,
-                         OutException(exception).get());
+  get_interface<PPB_Var_Deprecated>()->SetProperty(
+      var_, name.var_, value.var_, OutException(exception).get());
 }
 
 void Var::RemoveProperty(const Var& name, Var* exception) {
-  if (!ppb_var_f)
+  if (!has_interface<PPB_Var_Deprecated>())
     return;
-  ppb_var_f->RemoveProperty(var_, name.var_, OutException(exception).get());
+  get_interface<PPB_Var_Deprecated>()->RemoveProperty(
+      var_, name.var_, OutException(exception).get());
 }
 
 Var Var::Call(const Var& method_name, uint32_t argc, Var* argv,
               Var* exception) {
-  if (!ppb_var_f)
+  if (!has_interface<PPB_Var_Deprecated>())
     return Var();
   if (argc > 0) {
     std::vector<PP_Var> args;
     args.reserve(argc);
     for (size_t i = 0; i < argc; i++)
       args.push_back(argv[i].var_);
-    return Var(PassRef(), ppb_var_f->Call(var_, method_name.var_,
-                                          argc, &args[0],
-                                          OutException(exception).get()));
+    return Var(PassRef(), get_interface<PPB_Var_Deprecated>()->Call(
+        var_, method_name.var_, argc, &args[0], OutException(exception).get()));
   } else {
     // Don't try to get the address of a vector if it's empty.
-    return Var(PassRef(), ppb_var_f->Call(var_, method_name.var_, 0, NULL,
-                                          OutException(exception).get()));
+    return Var(PassRef(), get_interface<PPB_Var_Deprecated>()->Call(
+        var_, method_name.var_, 0, NULL, OutException(exception).get()));
   }
 }
 
 Var Var::Construct(uint32_t argc, Var* argv, Var* exception) const {
-  if (!ppb_var_f)
+  if (!has_interface<PPB_Var_Deprecated>())
     return Var();
   if (argc > 0) {
     std::vector<PP_Var> args;
     args.reserve(argc);
     for (size_t i = 0; i < argc; i++)
       args.push_back(argv[i].var_);
-    return Var(PassRef(), ppb_var_f->Construct(var_, argc, &args[0],
-                                               OutException(exception).get()));
+    return Var(PassRef(), get_interface<PPB_Var_Deprecated>()->Construct(
+        var_, argc, &args[0], OutException(exception).get()));
   } else {
     // Don't try to get the address of a vector if it's empty.
-    return Var(PassRef(), ppb_var_f->Construct(var_, 0, NULL,
-                                               OutException(exception).get()));
+    return Var(PassRef(), get_interface<PPB_Var_Deprecated>()->Construct(
+        var_, 0, NULL, OutException(exception).get()));
   }
 }
 
 Var Var::Call(const Var& method_name, Var* exception) {
-  if (!ppb_var_f)
+  if (!has_interface<PPB_Var_Deprecated>())
     return Var();
-  return Var(PassRef(), ppb_var_f->Call(var_, method_name.var_, 0, NULL,
-                                        OutException(exception).get()));
+  return Var(PassRef(), get_interface<PPB_Var_Deprecated>()->Call(
+      var_, method_name.var_, 0, NULL, OutException(exception).get()));
 }
 
 Var Var::Call(const Var& method_name, const Var& arg1, Var* exception) {
-  if (!ppb_var_f)
+  if (!has_interface<PPB_Var_Deprecated>())
     return Var();
   PP_Var args[1] = {arg1.var_};
-  return Var(PassRef(), ppb_var_f->Call(var_, method_name.var_, 1, args,
-                                        OutException(exception).get()));
+  return Var(PassRef(), get_interface<PPB_Var_Deprecated>()->Call(
+      var_, method_name.var_, 1, args, OutException(exception).get()));
 }
 
 Var Var::Call(const Var& method_name, const Var& arg1, const Var& arg2,
               Var* exception) {
-  if (!ppb_var_f)
+  if (!has_interface<PPB_Var_Deprecated>())
     return Var();
   PP_Var args[2] = {arg1.var_, arg2.var_};
-  return Var(PassRef(), ppb_var_f->Call(var_, method_name.var_, 2, args,
-                                        OutException(exception).get()));
+  return Var(PassRef(), get_interface<PPB_Var_Deprecated>()->Call(
+      var_, method_name.var_, 2, args, OutException(exception).get()));
 }
 
 Var Var::Call(const Var& method_name, const Var& arg1, const Var& arg2,
               const Var& arg3, Var* exception) {
-  if (!ppb_var_f)
+  if (!has_interface<PPB_Var_Deprecated>())
     return Var();
   PP_Var args[3] = {arg1.var_, arg2.var_, arg3.var_};
-  return Var(PassRef(), ppb_var_f->Call(var_, method_name.var_, 3, args,
-                                        OutException(exception).get()));
+  return Var(PassRef(), get_interface<PPB_Var_Deprecated>()->Call(
+      var_, method_name.var_, 3, args, OutException(exception).get()));
 }
 
 Var Var::Call(const Var& method_name, const Var& arg1, const Var& arg2,
               const Var& arg3, const Var& arg4, Var* exception) {
-  if (!ppb_var_f)
+  if (!has_interface<PPB_Var_Deprecated>())
     return Var();
   PP_Var args[4] = {arg1.var_, arg2.var_, arg3.var_, arg4.var_};
-  return Var(PassRef(), ppb_var_f->Call(var_, method_name.var_, 4, args,
-                                        OutException(exception).get()));
+  return Var(PassRef(), get_interface<PPB_Var_Deprecated>()->Call(
+      var_, method_name.var_, 4, args, OutException(exception).get()));
 }
 
 std::string Var::DebugString() const {