PPAPI: Add test for new-style permission for Sockets

ppapi/tests/extensions/packaged_app/test_packaged_app.cc

 // Copyright (c) 2014 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 <pthread.h>
 #include <unistd.h>
 
 #include <sstream>
 #include <string>
 
 #include "native_client/src/untrusted/irt/irt.h"
 
 #include "ppapi/cpp/completion_callback.h"
 #include "ppapi/cpp/instance.h"
 #include "ppapi/cpp/module.h"
+#include "ppapi/cpp/tcp_socket.h"
 #include "ppapi/cpp/var.h"
+#include "ppapi/utility/completion_callback_factory.h"
 
 namespace {
 
 std::string g_last_error;
 pp::Instance* g_instance = NULL;
 
 // This should be the same as FileDescriptorSet::kMaxDescriptorsPerMessage in
 // ipc/file_descriptor_set_posix.h.
 // TODO(yusukes): Once all the NaCl toolchains support C++11, Add
 // #include "ipc/file_descriptor_set_posix.h" and remove the constant.
@@ skipping 65 matching lines @@
     // returned from open_resource has its own file offset.
     if (!LoadManifestInternal(&nacl_irt_resource_open, key.str(), content))
       break;
   }
 }
 
 void PostReply(void* user_data, int32_t status) {
   if (!g_last_error.empty())
     g_instance->PostMessage(g_last_error.c_str());
   else
-    g_instance->PostMessage("Test passed");
+    g_instance->PostMessage("PASS");
 }
 
 void* RunTestsOnBackgroundThread(void* thread_id) {
   LoadManifest();
   pp::Module::Get()->core()->CallOnMainThread(
       0, pp::CompletionCallback(&PostReply, NULL));
   return NULL;
 }
 
 class MyInstance : public pp::Instance {
  public:
-  explicit MyInstance(PP_Instance instance) : pp::Instance(instance) {
+  explicit MyInstance(PP_Instance instance)
+      : pp::Instance(instance), socket_(this), factory_(this) {
     g_instance = this;
   }
   virtual ~MyInstance() { }
 
+  void DidBindSocket(int32_t result) {
+    // We didn't ask for socket permission in our manifest, so it should fail.
+    if (result == PP_ERROR_NOACCESS)
+      PostMessage("PASS");
+    else
+      PostMessage(result);
+  }
+
   virtual bool Init(uint32_t argc, const char* argn[], const char* argv[]) {
     pthread_t thread;
     // irt_open_resource() isn't allowed to be called on the main thread once
     // Pepper starts, so the test must happen on a background thread.
     if (pthread_create(&thread, NULL, &RunTestsOnBackgroundThread, NULL)) {
       g_last_error = "pthread_create failed";
       PostReply(NULL, 0);
     }
+    // Attempt to bind a socket. We don't have permissions, so it should fail.
+    PP_NetAddress_IPv4 ipv4_address = {80, {127, 0, 0, 1} };
+    pp::NetAddress address(this, ipv4_address);
+    socket_.Bind(address, factory_.NewCallback(&MyInstance::DidBindSocket));
     return true;
   }
+
+ private:
+  pp::TCPSocket socket_;
+  pp::CompletionCallbackFactory<MyInstance> factory_;
 };
 
 class MyModule : public pp::Module {
  public:
   MyModule() : pp::Module() { }
   virtual ~MyModule() { }
 
   virtual pp::Instance* CreateInstance(PP_Instance instance) {
     return new MyInstance(instance);
   }
 };
 
 }  // namespace
 
 namespace pp {
 
 Module* CreateModule() {
   return new MyModule();
 }
 
 }  // namespace pp