Remove unnecessary NSString conversions in sandbox_mac.mm.

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>
 #include <stddef.h>
 #include <stdint.h>
 
@@ skipping 341 matching lines @@
 
     // Allow the process to continue without a LaunchServices ASN. The
     // INIT_Process function in HIServices will abort if it cannot connect to
     // launchservicesd to get an ASN. By setting this flag, HIServices skips
     // that.
     SetApplicationIsDaemon(true);
   }
 }
 
 // Load the appropriate template for the given sandbox type.
-// Returns the template as an NSString or nil on error.
-NSString* LoadSandboxTemplate(int sandbox_type) {
+// Returns the template as a string or an empty string on error.
+std::string LoadSandboxTemplate(int sandbox_type) {
   // We use a custom sandbox definition to lock things down as tightly as
   // possible.
   int sandbox_profile_resource_id = -1;
 
   // Find resource id for sandbox profile to use for the specific sandbox type.
   for (size_t i = 0;
        i < arraysize(kDefaultSandboxTypeToResourceIDMapping);
        ++i) {
     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 =
         GetContentClient()->GetSandboxProfileForSandboxType(
             sandbox_type, &sandbox_profile_resource_id);
     CHECK(sandbox_type_found) << "Unknown sandbox type " << sandbox_type;
   }
 
   base::StringPiece sandbox_definition =
       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;
+    return std::string();
   }
 
   base::StringPiece common_sandbox_definition =
       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;
+    return std::string();
   }
 
-  base::scoped_nsobject<NSString> common_sandbox_prefix_data(
-      [[NSString alloc] initWithBytes:common_sandbox_definition.data()
-                               length:common_sandbox_definition.length()
-                             encoding:NSUTF8StringEncoding]);
-
-  base::scoped_nsobject<NSString> sandbox_data(
-      [[NSString alloc] initWithBytes:sandbox_definition.data()
-                               length:sandbox_definition.length()
-                             encoding:NSUTF8StringEncoding]);
-
   // Prefix sandbox_data with common_sandbox_prefix_data.
-  return [common_sandbox_prefix_data stringByAppendingString:sandbox_data];
+  std::string sandbox_profile = common_sandbox_definition.as_string();
+  sandbox_definition.AppendToString(&sandbox_profile);
+  return sandbox_profile;
 }
 
 // Turns on the OS X sandbox for this process.
 
 // static
 bool Sandbox::EnableSandbox(int sandbox_type,
                             const base::FilePath& allowed_dir) {
   // Sanity - currently only SANDBOX_TYPE_UTILITY supports a directory being
   // passed in.
   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) {
+  std::string sandbox_data = LoadSandboxTemplate(sandbox_type);
+  if (sandbox_data.empty()) {
     return false;
   }
 
-  SandboxCompiler compiler([sandbox_data UTF8String]);
+  SandboxCompiler compiler(sandbox_data);
 
   if (!allowed_dir.empty()) {
     // Add the sandbox parameters necessary to access the given directory.
     base::FilePath allowed_dir_canonical = GetCanonicalSandboxPath(allowed_dir);
     std::string regex;
     if (!QuoteStringForRegex(allowed_dir_canonical.value(), &regex)) {
       FatalStringQuoteException(allowed_dir_canonical.value());
       return false;
     }
     if (!compiler.InsertStringParam("PERMITTED_DIR", regex))
@@ skipping 61 matching lines @@
   if (HANDLE_EINTR(fcntl(fd.get(), F_GETPATH, canonical_path)) != 0) {
     DPLOG(FATAL) << "GetCanonicalSandboxPath() failed for: "
                  << path.value();
     return path;
   }
 
   return base::FilePath(canonical_path);
 }
 
 }  // namespace content