Add the UtilityProcessMojoClient class and convert SafeJsonParser

content/browser/utility_process_mojo_client_browsertest.cc

+// Copyright 2016 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 "content/public/browser/utility_process_mojo_client.h"
+
+#include <memory>
+
+#include "base/bind.h"
+#include "base/run_loop.h"
+#include "content/public/browser/browser_thread.h"
+#include "content/public/test/content_browser_test.h"
+#include "content/public/test/test_mojo_service.mojom.h"
+
+namespace content {
+
+enum class TestCase {
+  // Value of result_test_case_ before assignment.
+  NONE,
+  // Successful call through the Mojo service with response back.
+  CALL_SERVICE,
+  // Call the Mojo service but the utility process terminates before getting
+  // the result back.
+  CONNECTION_ERROR,
+  // Call a function that fails because the sandbox is still enabled.
+  SANDBOX_FAILURE,
+  // Call a function that succeeds only when the sandbox is disabled.
+  SANDBOX_SUCCESS,
+};
+
+// Test fixture used to make different Mojo calls to the utility process.
+// Depending on the test parameter, a different function on the Mojo service
+// will be invoked.
+class UtilityProcessMojoClientBrowserTest
+    : public ContentBrowserTest,
+      public ::testing::WithParamInterface<TestCase> {
+ public:
+  void StartTestOnIOThread() {

[Anand Mistry (off Chromium), 2016/06/10 11:13:54]

Part of the point of the helper is that it doesn't need to run on the IO thread.
The thread just has to have a message loop. I'd argue this would be a better
test if it didn't run on the IO thread.

[Patrick Monette, 2016/06/10 18:13:23]

Done. It even simplified the test.

+    mojo_client_.reset(new UtilityProcessMojoClient<mojom::TestMojoService>(
+        L"TestMojoProcess"));
+    mojo_client_->set_error_handler(
+        base::Bind(&UtilityProcessMojoClientBrowserTest::EndTestOnIoThread,
+                   base::Unretained(this), TestCase::CONNECTION_ERROR));
+
+    TestCase test_case = GetParam();
+    // This test case needs to have the sandbox disabled.
+    if (test_case == TestCase::SANDBOX_SUCCESS)
+      mojo_client_->set_disable_sandbox();
+    mojo_client_->Start();
+
+    switch (test_case) {
+      case TestCase::CALL_SERVICE:
+        mojo_client_->service()->DoSomething(
+            base::Bind(&UtilityProcessMojoClientBrowserTest::EndTestOnIoThread,
+                       base::Unretained(this), TestCase::CALL_SERVICE));
+        break;
+      case TestCase::CONNECTION_ERROR:
+        mojo_client_->service()->DoTerminateProcess(
+            base::Bind(&UtilityProcessMojoClientBrowserTest::EndTestOnIoThread,
+                       base::Unretained(this), TestCase::CALL_SERVICE));
+        break;
+      case TestCase::SANDBOX_FAILURE:
+      case TestCase::SANDBOX_SUCCESS:
+        mojo_client_->service()->CreateFolder(base::Bind(
+            &UtilityProcessMojoClientBrowserTest::OnCreateFolderFinished,
+            base::Unretained(this)));
+        break;
+      case TestCase::NONE:
+        FAIL();
+        break;
+    }
+  }
+
+ protected:
+  void EndTestOnIoThread(TestCase result_test_case) {
+    result_test_case_ = result_test_case;
+    mojo_client_.reset();
+    BrowserThread::PostTask(BrowserThread::UI, FROM_HERE, done_closure_);
+  }
+
+  void OnCreateFolderFinished(bool succeeded) {
+    EndTestOnIoThread(succeeded ? TestCase::SANDBOX_SUCCESS
+                                : TestCase::SANDBOX_FAILURE);
+  }
+
+  std::unique_ptr<UtilityProcessMojoClient<mojom::TestMojoService>>
+      mojo_client_;
+  base::Closure done_closure_;
+
+  // The test result that is compared to the current test case.
+  TestCase result_test_case_ = TestCase::NONE;
+};
+
+IN_PROC_BROWSER_TEST_P(UtilityProcessMojoClientBrowserTest, UtilityProcess) {
+  base::RunLoop run_loop;
+  done_closure_ = run_loop.QuitClosure();
+  BrowserThread::PostTask(
+      BrowserThread::IO, FROM_HERE,
+      base::Bind(&UtilityProcessMojoClientBrowserTest::StartTestOnIOThread,
+                 base::Unretained(this)));
+  run_loop.Run();
+  EXPECT_EQ(GetParam(), result_test_case_);
+}
+
+INSTANTIATE_TEST_CASE_P(TestCases,
+                        UtilityProcessMojoClientBrowserTest,
+                        ::testing::Values(TestCase::CALL_SERVICE,
+                                          TestCase::CONNECTION_ERROR,
+                                          TestCase::SANDBOX_FAILURE,
+                                          TestCase::SANDBOX_SUCCESS));
+
+}  // namespace content