Load mac sandbox definitions from resources instead of the bundle.

content/common/sandbox_mac_unittest_helper.mm

 // 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 "content/common/sandbox_mac_unittest_helper.h"
 
 extern "C" {
 #include <sandbox.h>
 }
 
 #include <map>
 
 #include "base/file_path.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "content/common/sandbox_mac.h"
+#include "content/test/test_content_client.h"
+#include "grit/content_resources.h"
 #include "testing/multiprocess_func_list.h"
 
 using sandbox::Sandbox;
 
 namespace {
 
 const char* kSandboxTypeKey = "CHROMIUM_SANDBOX_SANDBOX_TYPE";
 const char* kSandboxTestNameKey = "CHROMIUM_SANDBOX_TEST_NAME";
 const char* kTestDataKey = "CHROMIUM_SANDBOX_USER_DATA";
 
+const int kSandboxDefinitionResourceIds[] = {
+  IDR_GPU_SANDBOX_DEFINITION,
+  IDR_WORKER_SANDBOX_DEFINITION,
+  IDR_COMMON_SANDBOX_DEFINITION,
+  IDR_PPAPI_SANDBOX_DEFINITION,
+  IDR_RENDERER_SANDBOX_DEFINITION,
+  IDR_UTILITY_SANDBOX_DEFINITION,
+};
+
 }  // namespace
 
 namespace sandboxtest {
 
 // Support infrastructure for REGISTER_SANDBOX_TEST_CASE macro.
 namespace internal {
 
 typedef std::map<std::string,MacSandboxTestCase*> SandboxTestMap;
 
 // A function that returns a common map from string -> test case class.
@@ skipping 10 matching lines @@
   }
   test_map[test_name] = test_class;
 }
 
 }  // namespace internal
 
 bool MacSandboxTest::RunTestInAllSandboxTypes(const char* test_name,
                                               const char* test_data) {
   // Go through all the sandbox types, and run the test case in each of them
   // if one fails, abort.
-  for(int i = static_cast<int>(Sandbox::SANDBOX_TYPE_FIRST_TYPE);
-      i < Sandbox::SANDBOX_AFTER_TYPE_LAST_TYPE;
-      ++i) {
+  for(unsigned i = 0; i < arraysize(kSandboxDefinitionResourceIds); ++i) {
 
-    if (!RunTestInSandbox(static_cast<Sandbox::SandboxProcessType>(i),
+    if (!RunTestInSandbox(kSandboxDefinitionResourceIds[i],
             test_name, test_data)) {
       LOG(ERROR) << "Sandboxed test (" << test_name << ")" <<
           "Failed in sandbox type " << i <<
-          "user data: (" << test_data << ")";
+          " user data: (" << test_data << ")";
       return false;
     }
   }
  return true;
 }
 
-bool MacSandboxTest::RunTestInSandbox(Sandbox::SandboxProcessType sandbox_type,
+bool MacSandboxTest::RunTestInSandbox(int sandbox_definition_resource_id,
                                       const char* test_name,
                                       const char* test_data) {
   std::stringstream s;
-  s << static_cast<int>(static_cast<int>(sandbox_type));
+  s << sandbox_definition_resource_id;
   setenv(kSandboxTypeKey, s.str().c_str(), 1);
   setenv(kSandboxTestNameKey, test_name, 1);
   if (test_data)
     setenv(kTestDataKey, test_data, 1);
 
   base::ProcessHandle child_process = SpawnChild("mac_sandbox_test_runner",
                                                  false);
   if (child_process == base::kNullProcessHandle) {
     LOG(WARNING) << "SpawnChild failed";
     return false;
@@ skipping 31 matching lines @@
   return it->second;
 }
 
 }  // namespace sandboxtest
 
 namespace {
 
 // Main function for driver process that enables the sandbox and runs test
 // code.
 MULTIPROCESS_TEST_MAIN(mac_sandbox_test_runner) {
+  TestContentClient content_client;
+  content::SetContentClient(&content_client);
   // Extract parameters.
   char* sandbox_type_str = getenv(kSandboxTypeKey);
   if (!sandbox_type_str) {
     LOG(ERROR) << "Sandbox type not specified";
     return -1;
   }
-  Sandbox::SandboxProcessType sandbox_type =
-      static_cast<Sandbox::SandboxProcessType>(atoi(sandbox_type_str));
+  int sandbox_definition_resource_id = atoi(sandbox_type_str);
   char* sandbox_test_name = getenv(kSandboxTestNameKey);
   if (!sandbox_test_name) {
     LOG(ERROR) << "Sandbox test name not specified";
     return -1;
   }
 
   const char* test_data = getenv(kTestDataKey);
 
   // Find Test Function to run;
   scoped_ptr<sandboxtest::MacSandboxTestCase>
       test_case(sandboxtest::SandboxTestForName(sandbox_test_name));
   if (!test_case.get()) {
     LOG(ERROR) << "Invalid sandbox test name (" << sandbox_test_name << ")";
     return -1;
   }
   test_case->SetTestData(test_data);
 
   // Run Test.
   if (!test_case->BeforeSandboxInit()) {
     LOG(ERROR) << sandbox_test_name << "Failed test before sandbox init";
     return -1;
   }
 
-  Sandbox::SandboxWarmup(sandbox_type);
+  Sandbox::SandboxWarmup(sandbox_definition_resource_id);
 
-  if (!Sandbox::EnableSandbox(sandbox_type, FilePath())) {
-    LOG(ERROR) << "Failed to initialize sandbox " << sandbox_type;
+  if (!Sandbox::EnableSandbox(sandbox_definition_resource_id, FilePath())) {
+    LOG(ERROR) << "Failed to initialize sandbox (definition resource id "
+               << sandbox_definition_resource_id << ")";
     return -1;
   }
 
   if (!test_case->SandboxedTest()) {
     LOG(ERROR) << sandbox_test_name << "Failed sandboxed test";
     return -1;
   }
 
   return 0;
 }
 
 }  // namespace