gin

ppapi/tests/test_instance_deprecated.cc

 // Copyright (c) 2012 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/tests/test_instance_deprecated.h"
 
 #include <assert.h>
-#include <iostream>
 
 #include "ppapi/c/ppb_var.h"
 #include "ppapi/cpp/module.h"
 #include "ppapi/cpp/dev/scriptable_object_deprecated.h"
 #include "ppapi/tests/testing_instance.h"
 
 namespace {
 
 static const char kSetValueFunction[] = "SetValue";
 static const char kSetExceptionFunction[] = "SetException";
@@ skipping 100 matching lines @@
 REGISTER_TEST_CASE(Instance);
 
 TestInstance::TestInstance(TestingInstance* instance) : TestCase(instance) {
 }
 
 bool TestInstance::Init() {
   return true;
 }
 
 TestInstance::~TestInstance() {
+  ResetTestObject();
+  // When running tests in process, some post conditions check that teardown
+  // happened successfully. We need to run the garbage collector to ensure that
+  // vars get released.
+  if (testing_interface_->IsOutOfProcess() == PP_FALSE)
+    testing_interface_->RunV8GC(instance_->pp_instance());
   // Save the fact that we were destroyed in sessionStorage. This tests that
   // we can ExecuteScript at instance destruction without crashing. It also
   // allows us to check that ExecuteScript will run and succeed in certain
   // cases. In particular, when the instance is destroyed by normal DOM
   // deletion, ExecuteScript will actually work. See
   // TestExecuteScriptInInstanceShutdown for that test. Note, however, that
   // ExecuteScript will *not* have an effect when the instance is destroyed
   // because the renderer was shut down.
   pp::Var ret = instance()->ExecuteScript(
       "sessionStorage.setItem('instance_destroyed', 'true');");
@@ skipping 72 matching lines @@
                               new ObjectWithChildren(i, num_descendents - 1,
                                                      IgnoreLeaks()));
       i->IgnoreLeakedVar(child_.pp_var().value.as_id);
     }
   }
  private:
   pp::VarPrivate child_;
 };
 
 std::string TestInstance::TestRecursiveObjects() {
-  // These should be deleted when we exit scope, so should not leak.
-  pp::VarPrivate not_leaked(instance(), new ObjectWithChildren(this, 50));
+  const int kNumChildren = 20;
+  {
+    // These should be deleted when we exit scope, so should not leak.
+    pp::VarPrivate not_leaked(instance(), new ObjectWithChildren(this,
+                                                                 kNumChildren));
+  }
+  // We need to run the GC multiple times until all of the vars are released.
+  // Each GC invocation will result in releasing a var, which will result in its
+  // children not having any references, allowing them also to be collected.
+  for (int i = 0; i < kNumChildren; ++i)
+    testing_interface_->RunV8GC(instance_->pp_instance());
 
   // Leak some, but tell TestCase to ignore the leaks. This test is run and then
   // reloaded (see ppapi_uitest.cc). If these aren't cleaned up when the first
   // run is torn down, they will show up as leaks in the second run.
   // NOTE: The ScriptableObjects are actually leaked, but they should be removed
   //       from the tracker. See below for a test that verifies that the
   //       destructor is not run.
   pp::VarPrivate leaked(
       instance(),
-      new ObjectWithChildren(this, 50, ObjectWithChildren::IgnoreLeaks()));
+      new ObjectWithChildren(this, kNumChildren,
+                             ObjectWithChildren::IgnoreLeaks()));
   // Now leak a reference to the root object. This should force the root and
   // all its descendents to stay in the tracker.
   LeakReferenceAndIgnore(leaked);
 
   PASS();
 }
 
 // A scriptable object that should cause a crash if its destructor is run. We
 // don't run the destructor for objects which the plugin leaks. This is to
 // prevent them doing dangerous things at cleanup time, such as executing script
@@ skipping 34 matching lines @@
   // that it was set as expected.
   pp::Var result = instance()->ExecuteScript(
       "sessionStorage.getItem('instance_destroyed');");
   ASSERT_TRUE(result.is_string());
   ASSERT_EQ(std::string("true"), result.AsString());
   instance()->ExecuteScript("sessionStorage.removeItem('instance_destroyed');");
 
   PASS();
 }