Add TestConnectFailure, TestGetHandleFailure and TestConnectAndPipe to PPAPI Broker UI test.

ppapi/tests/test_broker.cc

 // Copyright (c) 2010 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_broker.h"
 
+#include <cstring>
+#include <fstream>
+
+#include "base/memory/scoped_ptr.h"
 #include "ppapi/c/pp_errors.h"
+#include "ppapi/c/trusted/ppp_broker.h"
 #include "ppapi/c/trusted/ppb_broker_trusted.h"
-#include "ppapi/cpp/module.h"
+#include "ppapi/tests/test_utils.h"
 #include "ppapi/tests/testing_instance.h"
 
 REGISTER_TEST_CASE(Broker);
 
+namespace {
+
+const size_t  kTestMessageLength  = 30;

[ddorwin, 2011/10/27 18:19:46]

use arraysize() instead?

[xhwang, 2011/10/27 22:31:57]

Done.

+const char    kTestMessage[]      = "Hello Plugin! This is Broker!";
+const int32_t kTestSandboxSuccess =  0;

[ddorwin, 2011/10/27 18:19:46]

kBrokerIsUnsandboxed

I would write a string since 0 and 1 could occur on the pipe for other reasons.

[xhwang, 2011/10/27 22:31:57]

Done.

+const int32_t kTestSandboxFailure = -1;
+
+// Test whether the process is sandboxed or not as expected.
+bool TestSandbox(bool is_sandbox_expected) {

[ddorwin, 2011/10/27 18:19:46]

VerifyIsUnsandboxed

Since we're only testing it is unsandboxed, we don't need is_sandbox_expected
(always false).

[xhwang, 2011/10/27 22:31:57]

Done.

[xhwang, 2011/10/27 22:31:57]

Done.

+  bool success = true;
+  std::fstream fs;
+
+// FIXME: Add sandbox test for other platforms.

[ddorwin, 2011/10/27 18:19:46]

Move to an #else below and change to "Windows". Actually, see
http://codesearch.google.com/#OAMlx_jo-ck/src/webkit/plugins/ppapi/ppb_buffer....

Actually, since this just uses an fstream, all we need to do is change the
paths.

[xhwang, 2011/10/27 22:31:57]

Done.

+#if defined(OS_POSIX)
+  const char* const kWriteFile = "/tmp/broker_sandbox_test.txt";

[ddorwin, 2011/10/27 18:19:46]

/tmp/ppapi_...

Paths should be the only difference. Move these up with the other constants and
add appropriate Mac and Win ifdefs.

[xhwang, 2011/10/27 22:31:57]

Done.

+  fs.open(kWriteFile, std::fstream::out);
+  success &= (fs.fail() == is_sandbox_expected);
+  fs << "ochoococohoho";
+  success &= (fs.fail() == is_sandbox_expected);
+  fs.close();
+
+  const char* const kReadFile = "/var/log/messages";

[ddorwin, 2011/10/27 18:19:46]

messages does not exist on my Mac. kernel.log might be a reasonable replacement.
You can use #if defined(OS_MACOSX) to select this.

Move up with the write file.

[xhwang, 2011/10/27 22:31:57]

Done.

+  fs.open(kReadFile, std::fstream::in);
+  success &= (fs.fail() == is_sandbox_expected);
+  char buffer[16] = {0};
+  fs.read(buffer, 8);
+  success &= (fs.fail() == is_sandbox_expected);
+  fs << "this will not work";

[ddorwin, 2011/10/27 18:19:46]

Probably not necessary.

[xhwang, 2011/10/27 22:31:57]

Done.

+  success &= fs.fail();
+  fs.close();
+#endif
+
+  return success;
+}
+
+// Callback in the broker when a new broker connection occurs.
+int32_t OnInstanceConnected(PP_Instance instance, int32_t handle) {
+  // Send test message
+  ::write(handle, kTestMessage, kTestMessageLength);
+
+  // Do sandbox test and send result to plugin over the pipe.
+  const bool kIsChromeSandboxEnabled = false;
+  int32_t test_sandbox_result = TestSandbox(kIsChromeSandboxEnabled) ?
+      kTestSandboxSuccess : kTestSandboxFailure;
+  ::write(handle, &test_sandbox_result, sizeof(test_sandbox_result));
+
+  ::close(handle);
+  return PP_OK;
+}
+
+} // namespace
+
+PP_EXPORT int32_t PPP_InitializeBroker(
+    PP_ConnectInstance_Func* connect_instance_func) {
+  *connect_instance_func = &OnInstanceConnected;
+  return PP_OK;
+}
+
+PP_EXPORT void PPP_ShutdownBroker() {}
+
 TestBroker::TestBroker(TestingInstance* instance)
     : TestCase(instance),
       broker_interface_(NULL) {
 }
 
 bool TestBroker::Init() {
   broker_interface_ = static_cast<PPB_BrokerTrusted const*>(
       pp::Module::Get()->GetBrowserInterface(PPB_BROKER_TRUSTED_INTERFACE));
   return !!broker_interface_;
 }
 
 void TestBroker::RunTest() {
   RUN_TEST(Create);
+  RUN_TEST(Connect);
 }
 
 std::string TestBroker::TestCreate() {
   // Very simplistic test to make sure we can create a broker interface.
   PP_Resource broker = broker_interface_->CreateTrusted(
       instance_->pp_instance());
   ASSERT_TRUE(broker);
 
   ASSERT_FALSE(broker_interface_->IsBrokerTrusted(0));
   ASSERT_TRUE(broker_interface_->IsBrokerTrusted(broker));
 
   // Test getting the handle for an invalid resource.
   int32_t handle;
   ASSERT_TRUE(broker_interface_->GetHandle(0, &handle) == PP_ERROR_BADRESOURCE);
 
   // Connect hasn't been called so this should fail.
   ASSERT_TRUE(broker_interface_->GetHandle(broker, &handle) == PP_ERROR_FAILED);
 

[ddorwin, 2011/10/27 18:19:46]

There is more testing of Connect and the handle that could be done here.

[xhwang, 2011/10/27 22:31:57]

?? Don't get it... 

[ddorwin, 2011/10/27 23:21:23]

As discussed.

   PASS();
 }
+
+std::string TestBroker::TestConnect() {

[ddorwin, 2011/10/27 18:19:46]

...AndGetHandle

[xhwang, 2011/10/27 22:31:57]

Done.

+  ASSERT_TRUE(broker_interface_);

[ddorwin, 2011/10/27 18:19:46]

I think this is an assumption in all tests, so we probably don't need it.

[xhwang, 2011/10/27 22:31:57]

Done.

+  PP_Resource broker = broker_interface_->CreateTrusted(
+      instance_->pp_instance());
+  ASSERT_TRUE(broker);
+
+  TestCompletionCallback cb(instance_->pp_instance());
+
+  ASSERT_EQ(PP_OK_COMPLETIONPENDING, broker_interface_->Connect(

[ddorwin, 2011/10/27 18:19:46]

I'm not sure why the existing test uses ASSERT, but EXPECT is usually better
unless a failure will cause a crash in the test.

[xhwang, 2011/10/27 22:31:57]

EXPECT is no available :-(

+      broker, pp::CompletionCallback(cb).pp_completion_callback()));
+  ASSERT_EQ(PP_OK, cb.WaitForResult());
+
+  int32_t handle = -1;

[ddorwin, 2011/10/27 18:19:46]

Can we use PlatformFileToInt(base::kInvalidPlatformFileValue)?
See
http://codesearch.google.com/#OAMlx_jo-ck/src/webkit/plugins/ppapi/ppb_broker....

You can then EXPECT_NE(PlatformFileToInt(base::kInvalidPlatformFileValue),
handle); below.

[xhwang, 2011/10/27 22:31:57]

Done.

+  ASSERT_EQ(PP_OK, broker_interface_->GetHandle(broker, &handle));
+
+  scoped_array<char> received_msg(new char[kTestMessageLength]);
+  ::read(handle, received_msg.get(), kTestMessageLength);
+  ASSERT_EQ(0, ::strcmp(received_msg.get(), kTestMessage));

[ddorwin, 2011/10/27 18:19:46]

EXPECT_STREQ

+
+  int32_t test_sandbox_result = kTestSandboxFailure;
+  ::read(handle, &test_sandbox_result, sizeof(test_sandbox_result));
+  ASSERT_EQ(kTestSandboxSuccess, test_sandbox_result);
+
+  ASSERT_EQ(0, ::close(handle));
+
+  PASS();
+}