Port nacl_integration exit_status test to browser_tests.

chrome/test/nacl/nacl_browsertest_util.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 "chrome/test/nacl/nacl_browsertest_util.h"
 
 #include "base/command_line.h"
 #include "base/json/json_reader.h"
 #include "base/path_service.h"
 #include "base/values.h"
@@ skipping 78 matching lines @@
       return MissingField(type, "message");
     if (!msg->GetBoolean("passed", &test_passed_))
       return MissingField(type, "passed");
     Log("SHUTDOWN", message);
     return DONE;
   } else {
     return InternalError("Unknown message type: " + type);
   }
 }
 
+// A message handler for nacl_integration tests ported to be browser_tests.
+// nacl_integration tests report to their test jig using a series of RPC calls
+// that are encoded as URL requests. When these tests run as browser_tests,
+// they make the same RPC requests, but use the automation channel instead of
+// URL requests.  This message handler decodes and responds to these requests.

[Mark Seaborn, 2012/09/12 18:09:45]

Be consistent about using 1 or 2 spaces between sentences

[Nick Bray (chromium), 2012/09/12 20:50:59]

Done.

+class NaClIntegrationMessageHandler : public StructuredMessageHandler {
+ public:
+  NaClIntegrationMessageHandler();
+
+  void Log(const std::string& message);
+
+  virtual MessageResponse HandleStructuredMessage(
+      const std::string& type,
+      base::DictionaryValue* msg) OVERRIDE;
+
+  bool test_passed() const {
+    return test_passed_;
+  }
+
+ private:
+  bool test_passed_;
+
+  DISALLOW_COPY_AND_ASSIGN(NaClIntegrationMessageHandler);
+};
+
+NaClIntegrationMessageHandler::NaClIntegrationMessageHandler()
+    : test_passed_(false) {
+}
+
+void NaClIntegrationMessageHandler::Log(const std::string& message) {
+  // TODO(ncbray) better logging.
+  LOG(INFO) << "|||| " << message;
+}
+
+MessageResponse NaClIntegrationMessageHandler::HandleStructuredMessage(
+    const std::string& type,
+    DictionaryValue* msg) {
+  if (type == "TestLog") {
+    std::string message;
+    if (!msg->GetString("message", &message))
+      return MissingField(type, "message");
+    Log(message);
+    return CONTINUE;
+  } else if (type == "Shutdown") {
+    std::string message;
+    if (!msg->GetString("message", &message))
+      return MissingField(type, "message");
+    if (!msg->GetBoolean("passed", &test_passed_))
+      return MissingField(type, "passed");
+    Log(message);
+    return DONE;
+  } else if (type == "Ping") {
+    return CONTINUE;
+  } else if (type == "JavaScriptIsAlive") {
+    return CONTINUE;
+  } else {
+    return InternalError("Unknown message type: " + type);
+  }
+}
+
 // NaCl browser tests serve files out of the build directory because nexes and
 // pexes are artifacts of the build.  To keep things tidy, all test data is kept
 // in a subdirectory.  Several variants of a test may be run, for example when
 // linked against newlib and when linked against glibc.  These variants are kept
 // in different subdirectories.  For example, the build directory will look
 // something like this on Linux:
 // out/
 //     Release/
 //             nacl_test_data/
 //                            newlib/
@@ skipping 20 matching lines @@
 
 void NaClBrowserTestBase::SetUpInProcessBrowserTestFixture() {
   // Sanity check.
   FilePath plugin_lib;
   ASSERT_TRUE(PathService::Get(chrome::FILE_NACL_PLUGIN, &plugin_lib));
   ASSERT_TRUE(file_util::PathExists(plugin_lib)) << plugin_lib.value();
 
   ASSERT_TRUE(StartTestServer()) << "Cannot start test server.";
 }
 
-GURL NaClBrowserTestBase::TestURL(const FilePath::StringType& test_file) {
-  FilePath real_path = test_server_->document_root().Append(test_file);
-  EXPECT_TRUE(file_util::PathExists(real_path)) << real_path.value();
-
-  FilePath url_path = FilePath(FILE_PATH_LITERAL("files"));
-  url_path = url_path.Append(test_file);
-  return test_server_->GetURL(url_path.MaybeAsASCII());
+GURL NaClBrowserTestBase::TestURL(const FilePath::StringType& url_fragment) {
+  FilePath expanded_url = FilePath(FILE_PATH_LITERAL("files"));
+  expanded_url = expanded_url.Append(url_fragment);
+  return test_server_->GetURL(expanded_url.MaybeAsASCII());
 }
 
 bool NaClBrowserTestBase::RunJavascriptTest(const GURL& url,
                                             TestMessageHandler* handler) {
   JavascriptTestObserver observer(
       chrome::GetActiveWebContents(browser())->GetRenderViewHost(),
       handler);
   ui_test_utils::NavigateToURL(browser(), url);
   return observer.Run();
 }
 
 void NaClBrowserTestBase::RunLoadTest(const FilePath::StringType& test_file) {
   LoadTestMessageHandler handler;
   bool ok = RunJavascriptTest(TestURL(test_file), &handler);
   ASSERT_TRUE(ok) << handler.error_message();
   ASSERT_TRUE(handler.test_passed()) << "Test failed.";
 }
 
+void NaClBrowserTestBase::RunNaClIntegrationTest(
+    const FilePath::StringType& url_fragment) {
+  NaClIntegrationMessageHandler handler;
+  bool ok = RunJavascriptTest(TestURL(url_fragment), &handler);
+  ASSERT_TRUE(ok) << handler.error_message();
+  ASSERT_TRUE(handler.test_passed()) << "Test failed.";
+}
+
 bool NaClBrowserTestBase::StartTestServer() {
   // Launch the web server.
   FilePath document_root;
   if (!GetNaClVariantRoot(Variant(), &document_root))
     return false;
   test_server_.reset(new net::TestServer(net::TestServer::TYPE_HTTP,
                                          net::TestServer::kLocalhost,
                                          document_root));
   return test_server_->Start();
 }
 
 FilePath::StringType NaClBrowserTestNewlib::Variant() {
   return FILE_PATH_LITERAL("newlib");
 }
 
 FilePath::StringType NaClBrowserTestGLibc::Variant() {
   return FILE_PATH_LITERAL("glibc");
 }