Add GetLiveVars to PPB_Testing_Dev. Fix leaks it uncovered.

ppapi/cpp/var.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 "ppapi/cpp/var.h"
 
 #include <stdio.h>
 #include <string.h>
 
 #include <algorithm>
@@ skipping 86 matching lines @@
 
 Var::Var(const std::string& utf8_str) {
   var_ = VarFromUtf8Helper(utf8_str.c_str(),
                             static_cast<uint32_t>(utf8_str.size()));
   needs_release_ = (var_.type == PP_VARTYPE_STRING);
 }
 
 Var::Var(const Var& other) {
   var_ = other.var_;
   if (NeedsRefcounting(var_)) {
-    if (has_interface<PPB_Var>()) {
+    if (has_interface<PPB_Var_1_0>()) {
       needs_release_ = true;
       get_interface<PPB_Var_1_0>()->AddRef(var_);
     } else {
       var_.type = PP_VARTYPE_NULL;
       needs_release_ = false;
     }
   } else {
     needs_release_ = false;
   }
 }
 
 Var::~Var() {
-  if (needs_release_ && has_interface<PPB_Var>())
+  if (needs_release_ && has_interface<PPB_Var_1_0>())
     get_interface<PPB_Var_1_0>()->Release(var_);
 }
 
 Var& Var::operator=(const Var& other) {
   // Early return for self-assignment. Note however, that two distinct vars
   // can refer to the same object, so we still need to be careful about the
   // refcounting below.
   if (this == &other)
     return *this;
 
   // Be careful to keep the ref alive for cases where we're assigning an
   // object to itself by addrefing the new one before releasing the old one.
   bool old_needs_release = needs_release_;
   if (NeedsRefcounting(other.var_)) {
-    // Assume we already has_interface<PPB_Var> for refcounted vars or else we
-    // couldn't have created them in the first place.
+    // Assume we already has_interface<PPB_Var_1_0> for refcounted vars or else
+    // we couldn't have created them in the first place.
     needs_release_ = true;
     get_interface<PPB_Var_1_0>()->AddRef(other.var_);
   } else {
     needs_release_ = false;
   }
   if (old_needs_release)
     get_interface<PPB_Var_1_0>()->Release(var_);
 
   var_ = other.var_;
   return *this;
@@ skipping 49 matching lines @@
   PP_NOTREACHED();
   return 0.0;
 }
 
 std::string Var::AsString() const {
   if (!is_string()) {
     PP_NOTREACHED();
     return std::string();
   }
 
-  if (!has_interface<PPB_Var>())
+  if (!has_interface<PPB_Var_1_0>())
     return std::string();
   uint32_t len;
   const char* str = get_interface<PPB_Var_1_0>()->VarToUtf8(var_, &len);
   return std::string(str, len);
 }
 
 std::string Var::DebugString() const {
   char buf[256];
   if (is_undefined()) {
-    snprintf(buf, sizeof(buf), "Var<UNDEFINED>");
+    snprintf(buf, sizeof(buf), "Var(UNDEFINED)");
   } else if (is_null()) {
-    snprintf(buf, sizeof(buf), "Var<NULL>");
+    snprintf(buf, sizeof(buf), "Var(NULL)");
   } else if (is_bool()) {
-    snprintf(buf, sizeof(buf), AsBool() ? "Var<true>" : "Var<false>");
+    snprintf(buf, sizeof(buf), AsBool() ? "Var(true)" : "Var(false)");
   } else if (is_int()) {
     // Note that the following static_cast is necessary because
     // NativeClient's int32_t is actually "long".
     // TODO(sehr,polina): remove this after newlib is changed.
-    snprintf(buf, sizeof(buf), "Var<%d>", static_cast<int>(AsInt()));
+    snprintf(buf, sizeof(buf), "Var(%d)", static_cast<int>(AsInt()));
   } else if (is_double()) {
-    snprintf(buf, sizeof(buf), "Var<%f>", AsDouble());
+    snprintf(buf, sizeof(buf), "Var(%f)", AsDouble());
   } else if (is_string()) {
     char format[] = "Var<'%s'>";
     size_t decoration = sizeof(format) - 2;  // The %s is removed.
     size_t available = sizeof(buf) - decoration;
     std::string str = AsString();
     if (str.length() > available) {
       str.resize(available - 3);  // Reserve space for ellipsis.
       str.append("...");
     }
     snprintf(buf, sizeof(buf), format, str.c_str());
+  } else if (is_array_buffer()) {
+    // TODO(dmichael): We could make this dump hex. Maybe DebugString should be
+    // virtual?
+    snprintf(buf, sizeof(buf), "Var(ARRAY_BUFFER)");
   } else if (is_object()) {
-    snprintf(buf, sizeof(buf), "Var<OBJECT>");
+    snprintf(buf, sizeof(buf), "Var(OBJECT)");
   }
   return buf;
 }
 
 }  // namespace pp