Move sandbox code in content to content namespace.

content/common/sandbox_mac.mm

 // 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 "content/common/sandbox_mac.h"
 
 #import <Cocoa/Cocoa.h>
 
 extern "C" {
 #include <sandbox.h>
@@ skipping 18 matching lines @@
 #include "base/sys_info.h"
 #include "base/sys_string_conversions.h"
 #include "base/utf_string_conversions.h"
 #include "content/public/common/content_client.h"
 #include "content/public/common/content_switches.h"
 #include "grit/content_resources.h"
 #include "ui/base/layout.h"
 #include "ui/gl/gl_surface.h"
 #include "unicode/uchar.h"
 
+namespace content {
 namespace {
 
 struct SandboxTypeToResourceIDMapping {
-  content::SandboxType sandbox_type;
+  SandboxType sandbox_type;
   int sandbox_profile_resource_id;
 };
 
 // Mapping from sandbox process types to resource IDs containing the sandbox
 // profile for all process types known to content.
 SandboxTypeToResourceIDMapping kDefaultSandboxTypeToResourceIDMapping[] = {
-  { content::SANDBOX_TYPE_RENDERER, IDR_RENDERER_SANDBOX_PROFILE },
-  { content::SANDBOX_TYPE_WORKER,   IDR_WORKER_SANDBOX_PROFILE },
-  { content::SANDBOX_TYPE_UTILITY,  IDR_UTILITY_SANDBOX_PROFILE },
-  { content::SANDBOX_TYPE_GPU,      IDR_GPU_SANDBOX_PROFILE },
-  { content::SANDBOX_TYPE_PPAPI,    IDR_PPAPI_SANDBOX_PROFILE },
+  { SANDBOX_TYPE_RENDERER, IDR_RENDERER_SANDBOX_PROFILE },
+  { SANDBOX_TYPE_WORKER,   IDR_WORKER_SANDBOX_PROFILE },
+  { SANDBOX_TYPE_UTILITY,  IDR_UTILITY_SANDBOX_PROFILE },
+  { SANDBOX_TYPE_GPU,      IDR_GPU_SANDBOX_PROFILE },
+  { SANDBOX_TYPE_PPAPI,    IDR_PPAPI_SANDBOX_PROFILE },
 };
 
 COMPILE_ASSERT(arraysize(kDefaultSandboxTypeToResourceIDMapping) == \
-               size_t(content::SANDBOX_TYPE_AFTER_LAST_TYPE), \
+               size_t(SANDBOX_TYPE_AFTER_LAST_TYPE), \
                sandbox_type_to_resource_id_mapping_incorrect);
 
 // Try to escape |c| as a "SingleEscapeCharacter" (\n, etc).  If successful,
 // returns true and appends the escape sequence to |dst|.
 bool EscapeSingleChar(char c, std::string* dst) {
   const char *append = NULL;
   switch (c) {
     case '\b':
       append = "\\b";
       break;
@@ skipping 29 matching lines @@
 // in a central place.
 NOINLINE void FatalStringQuoteException(const std::string& str) {
   // Copy bad string to the stack so it's recorded in the crash dump.
   char bad_string[256] = {0};
   base::strlcpy(bad_string, str.c_str(), arraysize(bad_string));
   DLOG(FATAL) << "String quoting failed " << bad_string;
 }
 
 }  // namespace
 
-namespace sandbox {
-
 // static
 NSString* Sandbox::AllowMetadataForPath(const FilePath& allowed_path) {
   // Collect a list of all parent directories.
   FilePath last_path = allowed_path;
   std::vector<FilePath> subpaths;
   for (FilePath path = allowed_path;
        path.value() != last_path.value();
        path = path.DirName()) {
     subpaths.push_back(path);
     last_path = path;
@@ skipping 177 matching lines @@
         NULL));
     CGImageSourceGetStatus(img);
   }
 
   {
     // Allow access to /dev/urandom.
     base::GetUrandomFD();
   }
 
   // Process-type dependent warm-up.
-  if (sandbox_type == content::SANDBOX_TYPE_GPU) {
+  if (sandbox_type == SANDBOX_TYPE_GPU) {
     // Preload either the desktop GL or the osmesa so, depending on the
     // --use-gl flag.
     gfx::GLSurface::InitializeOneOff();
   }
 }
 
 // static
 NSString* Sandbox::BuildAllowDirectoryAccessSandboxString(
     const FilePath& allowed_dir,
     SandboxVariableSubstitions* substitutions) {
@@ skipping 42 matching lines @@
     if (kDefaultSandboxTypeToResourceIDMapping[i].sandbox_type ==
         sandbox_type) {
       sandbox_profile_resource_id =
           kDefaultSandboxTypeToResourceIDMapping[i].sandbox_profile_resource_id;
       break;
     }
   }
   if (sandbox_profile_resource_id == -1) {
     // Check if the embedder knows about this sandbox process type.
     bool sandbox_type_found =
-        content::GetContentClient()->GetSandboxProfileForSandboxType(
+        GetContentClient()->GetSandboxProfileForSandboxType(
             sandbox_type, &sandbox_profile_resource_id);
     CHECK(sandbox_type_found) << "Unknown sandbox type " << sandbox_type;
   }
 
   base::StringPiece sandbox_definition =
-      content::GetContentClient()->GetDataResource(
+      GetContentClient()->GetDataResource(
           sandbox_profile_resource_id, ui::SCALE_FACTOR_NONE);
   if (sandbox_definition.empty()) {
     LOG(FATAL) << "Failed to load the sandbox profile (resource id "
                << sandbox_profile_resource_id << ")";
     return nil;
   }
 
   base::StringPiece common_sandbox_definition =
-      content::GetContentClient()->GetDataResource(
+      GetContentClient()->GetDataResource(
           IDR_COMMON_SANDBOX_PROFILE, ui::SCALE_FACTOR_NONE);
   if (common_sandbox_definition.empty()) {
     LOG(FATAL) << "Failed to load the common sandbox profile";
     return nil;
   }
 
   scoped_nsobject<NSString> common_sandbox_prefix_data(
       [[NSString alloc] initWithBytes:common_sandbox_definition.data()
                                length:common_sandbox_definition.length()
                              encoding:NSUTF8StringEncoding]);
@@ skipping 76 matching lines @@
 }
 
 
 // Turns on the OS X sandbox for this process.
 
 // static
 bool Sandbox::EnableSandbox(int sandbox_type,
                             const FilePath& allowed_dir) {
   // Sanity - currently only SANDBOX_TYPE_UTILITY supports a directory being
   // passed in.
-  if (sandbox_type < content::SANDBOX_TYPE_AFTER_LAST_TYPE &&
-      sandbox_type != content::SANDBOX_TYPE_UTILITY) {
+  if (sandbox_type < SANDBOX_TYPE_AFTER_LAST_TYPE &&
+      sandbox_type != SANDBOX_TYPE_UTILITY) {
     DCHECK(allowed_dir.empty())
         << "Only SANDBOX_TYPE_UTILITY allows a custom directory parameter.";
   }
 
   NSString* sandbox_data = LoadSandboxTemplate(sandbox_type);
   if (!sandbox_data) {
     return false;
   }
 
   SandboxVariableSubstitions substitutions;
@@ skipping 96 matching lines @@
   FilePath::CharType canonical_path[MAXPATHLEN];
   if (HANDLE_EINTR(fcntl(fd, F_GETPATH, canonical_path)) != 0) {
     DPLOG(FATAL) << "GetCanonicalSandboxPath() failed for: "
                  << path.value();
     return path;
   }
 
   return FilePath(canonical_path);
 }
 
-}  // namespace sandbox
+}  // namespace content