Try to reduce the flankness of the PPAPI UI tests.

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>
 
 #include "ppapi/cpp/module.h"
 #include "ppapi/cpp/var.h"
 #include "ppapi/tests/test_case.h"
 
 TestCaseFactory* TestCaseFactory::head_ = NULL;
 
+// Cookie value we use to signal "we're still working." See the comment above
+// the class declaration for how this works.
+static const char kProgressCookie[] = "...";

[polina, 2011/08/22 23:53:58]

s/kProgressCookie/kProgressSignal/
Otherwise, it get confusing, what's a cookie, what's a value and what's a cookie
that's technically a PPAPI_PROGRESS cookie, but does not correspond to a
progress signal :).

+
 // Returns a new heap-allocated test case for the given test, or NULL on
 // failure.
 TestingInstance::TestingInstance(PP_Instance instance)
 #if (defined __native_client__)
     : pp::Instance(instance),
 #else
     : pp::InstancePrivate(instance),
 #endif
       current_case_(NULL),
+      progress_number_(0),
       executed_tests_(false),
       nacl_mode_(false) {
   callback_factory_.Initialize(this);
 }
 
 TestingInstance::~TestingInstance() {
   if (current_case_)
     delete current_case_;
 }
 
@@ skipping 44 matching lines @@
   if (!executed_tests_) {
     executed_tests_ = true;
     pp::Module::Get()->core()->CallOnMainThread(
         0,
         callback_factory_.NewCallback(&TestingInstance::ExecuteTests));
   }
 }
 
 void TestingInstance::LogTest(const std::string& test_name,
                               const std::string& error_message) {
+  // Tell the browser we're still working.
+  ReportProgress(kProgressCookie);
+
   std::string html;
   html.append("<div class=\"test_line\"><span class=\"test_name\">");
   html.append(test_name);
   html.append("</span> ");
   if (error_message.empty()) {
     html.append("<span class=\"pass\">PASS</span>");
   } else {
     html.append("<span class=\"fail\">FAIL</span>: <span class=\"err_msg\">");
     html.append(error_message);
     html.append("</span>");
 
     if (!errors_.empty())
       errors_.append(", ");  // Separator for different error messages.
     errors_.append(test_name + " FAIL: " + error_message);
   }
   html.append("</div>");
   LogHTML(html);
 }
 
 void TestingInstance::AppendError(const std::string& message) {
   if (!errors_.empty())
     errors_.append(", ");
   errors_.append(message);
 }
 
 void TestingInstance::ExecuteTests(int32_t unused) {
-  SetCookie("STARTUP_COOKIE", "STARTED");
+  ReportProgress(kProgressCookie);
 
   // Clear the console.
   PostMessage(pp::Var("TESTING_MESSAGE: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_->RunTest();
     // 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.
-  SetCookie("COMPLETION_COOKIE", errors_.empty() ? "PASS" : errors_);
+  ReportProgress(errors_.empty() ? "PASS" : errors_);
   PostMessage(pp::Var("TESTING_MESSAGE:DidExecuteTests"));
 }
 
 TestCase* TestingInstance::CaseForTestName(const char* name) {
   TestCaseFactory* iter = TestCaseFactory::head_;
   while (iter != NULL) {
     if (std::strcmp(name, iter->name_) == 0)
       return iter->method_(this);
     iter = iter->next_;
   }
@@ skipping 34 matching lines @@
   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));
 }
 
+void TestingInstance::ReportProgress(const std::string& progress_value) {
+  // Use streams since nacl doesn't compile base yet (for stringprintf).

[polina, 2011/08/22 23:53:58]

StringPrintf?

+  std::ostringstream cookie_name;
+  cookie_name << "PPAPI_PROGRESS_" << progress_number_;
+  SetCookie(cookie_name.str(), progress_value);
+  progress_number_++;
+}
+
 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));
 }
 
 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