PPAPI: Really force-free NPObjects on Instance destruction.

ppapi/tests/testing_instance.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/tests/testing_instance.h"
 
 #include <algorithm>
 #include <cstring>
 #include <sstream>
 #include <vector>
@@ skipping 84 matching lines @@
     current_case_->DidChangeView(view);
 }
 
 bool TestingInstance::HandleInputEvent(const pp::InputEvent& event) {
   if (current_case_)
     return current_case_->HandleInputEvent(event);
   return false;
 }
 
 void TestingInstance::EvalScript(const std::string& script) {
-  std::string message("TESTING_MESSAGE:EvalScript:");
-  message.append(script);
-  PostMessage(pp::Var(message));
+  SendTestCommand("EvalScript", script);
 }
 
 void TestingInstance::SetCookie(const std::string& name,
                                 const std::string& value) {
-  std::string message("TESTING_MESSAGE:SetCookie:");
-  message.append(name);
-  message.append("=");
-  message.append(value);
-  PostMessage(pp::Var(message));
+  SendTestCommand("SetCookie", name + "=" + value);
+}
+
+void TestingInstance::AddPostCondition(const std::string& script) {
+  SendTestCommand("AddPostCondition", script);
 }
 
 void TestingInstance::LogTest(const std::string& test_name,
                               const std::string& error_message) {
   // Tell the browser we're still working.
   ReportProgress(kProgressSignal);
 
   std::string html;
   html.append("<div class=\"test_line\"><span class=\"test_name\">");
   html.append(test_name);
@@ skipping 16 matching lines @@
 void TestingInstance::AppendError(const std::string& message) {
   if (!errors_.empty())
     errors_.append(", ");
   errors_.append(message);
 }
 
 void TestingInstance::ExecuteTests(int32_t unused) {
   ReportProgress(kProgressSignal);
 
   // Clear the console.
-  PostMessage(pp::Var("TESTING_MESSAGE:ClearConsole"));
+  SendTestCommand("ClearConsole");
 
   if (!errors_.empty()) {
     // Catch initialization errors and output the current error string to
     // the console.
     LogError("Plugin initialization failed: " + errors_);
   } else if (!current_case_) {
     LogAvailableTests();
     errors_.append("FAIL: Only listed tests");
   } else {
     current_case_->RunTests(test_filter_);
     // Automated PyAuto tests rely on finding the exact strings below.
     LogHTML(errors_.empty() ?
             "<span class=\"pass\">[SHUTDOWN]</span> All tests passed." :
             "<span class=\"fail\">[SHUTDOWN]</span> Some tests failed.");
   }
 
   // Declare we're done by setting a cookie to either "PASS" or the errors.
   ReportProgress(errors_.empty() ? "PASS" : errors_);
-  PostMessage(pp::Var("TESTING_MESSAGE:DidExecuteTests"));
+  SendTestCommand("DidExecuteTests");
+  // Note, DidExecuteTests unloads the plugin. We can't really do anthing after
+  // this point.
 }
 
 TestCase* TestingInstance::CaseForTestName(const std::string& name) {
   std::string case_name = name.substr(0, name.find_first_of('_'));
   TestCaseFactory* iter = TestCaseFactory::head_;
   while (iter != NULL) {
     if (case_name == iter->name_)
       return iter->method_(this);
     iter = iter->next_;
   }
   return NULL;
 }
 
 std::string TestingInstance::FilterForTestName(const std::string& name) {
   size_t delim = name.find_first_of('_');
   if (delim != std::string::npos)
     return name.substr(delim+1);
   return "";
 }
 
+void TestingInstance::SendTestCommand(const std::string& command) {
+  std::string msg("TESTING_MESSAGE:");
+  msg += command;
+  PostMessage(pp::Var(msg));
+}
+
+void TestingInstance::SendTestCommand(const std::string& command,
+                                      const std::string& params) {
+  SendTestCommand(command + ":" + params);
+}
+
+
 void TestingInstance::LogAvailableTests() {
   // Print out a listing of all tests.
   std::vector<std::string> test_cases;
   TestCaseFactory* iter = TestCaseFactory::head_;
   while (iter != NULL) {
     test_cases.push_back(iter->name_);
     iter = iter->next_;
   }
   std::sort(test_cases.begin(), test_cases.end());
 
@@ skipping 16 matching lines @@
 
 void TestingInstance::LogError(const std::string& text) {
   std::string html;
   html.append("<span class=\"fail\">FAIL</span>: <span class=\"err_msg\">");
   html.append(text);
   html.append("</span>");
   LogHTML(html);
 }
 
 void TestingInstance::LogHTML(const std::string& html) {
-  std::string message("TESTING_MESSAGE:LogHTML:");
-  message.append(html);
-  PostMessage(pp::Var(message));
+  SendTestCommand("LogHTML", html);
 }
 
 void TestingInstance::ReportProgress(const std::string& progress_value) {
   // Use streams since nacl doesn't compile base yet (for StringPrintf).
   std::ostringstream cookie_name;
   cookie_name << "PPAPI_PROGRESS_" << progress_cookie_number_;
   SetCookie(cookie_name.str(), progress_value);
   progress_cookie_number_++;
 }
 
 class Module : public pp::Module {
  public:
   Module() : pp::Module() {}
   virtual ~Module() {}
 
   virtual pp::Instance* CreateInstance(PP_Instance instance) {
     return new TestingInstance(instance);
   }
 };
 
 namespace pp {
 
 Module* CreateModule() {
   return new ::Module();
 }
 
 }  // namespace pp