Fix PPAPI TestCase so individual tests can be run more than once.

ppapi/tests/test_case.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_case.h"
 
 #include <string.h>
 
 #include <sstream>
 
@@ skipping 63 matching lines @@
   // There may be a trailing comma; ignore empty strings.
   remaining_tests->erase(std::string());
 }
 
 }  // namespace
 
 TestCase::TestCase(TestingInstance* instance)
     : instance_(instance),
       testing_interface_(NULL),
       callback_type_(PP_REQUIRED),
-      have_populated_remaining_tests_(false) {
+      have_populated_filter_tests_(false) {
   // Get the testing_interface_ if it is available, so that we can do Resource
   // and Var checks on shutdown (see CheckResourcesAndVars). If it is not
   // available, testing_interface_ will be NULL. Some tests do not require it.
   testing_interface_ = GetTestingInterface();
 }
 
 TestCase::~TestCase() {
 }
 
 bool TestCase::Init() {
@@ skipping 79 matching lines @@
 bool TestCase::ShouldRunAllTests(const std::string& filter) {
   // If only the TestCase is listed, we're running all the tests in RunTests.
   return (StripTestCase(filter) == std::string());
 }
 
 bool TestCase::ShouldRunTest(const std::string& test_name,
                              const std::string& filter) {
   if (ShouldRunAllTests(filter))
     return true;
 
-  // Lazily initialize our "remaining_tests_" map.
-  if (!have_populated_remaining_tests_) {
-    ParseTestFilter(filter, &remaining_tests_);
-    have_populated_remaining_tests_ = true;
+  // Lazily initialize our "filter_tests_" map.
+  if (!have_populated_filter_tests_) {
+    ParseTestFilter(filter, &filter_tests_);
+    remaining_tests_ = filter_tests_;
+    have_populated_filter_tests_ = true;
   }
-  std::map<std::string, bool>::iterator iter = remaining_tests_.find(test_name);
-  if (iter == remaining_tests_.end()) {
+  std::map<std::string, bool>::iterator iter = filter_tests_.find(test_name);
+  if (iter == filter_tests_.end()) {
     // The test name wasn't listed in the filter. Don't run it, but store it
     // so TestingInstance::ExecuteTests can report an error later.
     skipped_tests_.insert(test_name);
     return false;
   }
-  bool should_run_test = iter->second;
-  remaining_tests_.erase(iter);
-  return should_run_test;
+  remaining_tests_.erase(test_name);
+  return iter->second;
 }
 
 PP_TimeTicks TestCase::NowInTimeTicks() {
   return pp::Module::Get()->core()->GetTimeTicks();
 }
 
 std::string TestCase::CheckResourcesAndVars(std::string errors) {
   if (!errors.empty())
     return errors;
 
@@ skipping 48 matching lines @@
 void TestCase::RunOnThreadInternal(void (*thread_func)(void*),
                                    void* thread_param,
                                    const PPB_Testing_Dev* testing_interface) {
     PP_ThreadType thread;
     PP_CreateThread(&thread, thread_func, thread_param);
     // Run a message loop so pepper calls can be dispatched. The background
     // thread will set result_ and make us Quit when it's done.
     testing_interface->RunMessageLoop(instance_->pp_instance());
     PP_JoinThread(thread);
 }