Make base::Environment::Create() return unique_ptrs.

sandbox/linux/suid/client/setuid_sandbox_host.cc

 // Copyright 2015 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 "sandbox/linux/suid/client/setuid_sandbox_host.h"
 
 #include <fcntl.h>
 #include <stddef.h>
 #include <stdlib.h>
 #include <sys/stat.h>
@@ skipping 11 matching lines @@
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/path_service.h"
 #include "base/posix/eintr_wrapper.h"
 #include "base/process/launch.h"
 #include "base/process/process_metrics.h"
 #include "base/strings/string_number_conversions.h"
 #include "sandbox/linux/suid/common/sandbox.h"
 #include "sandbox/linux/suid/common/suid_unsafe_environment_variables.h"
 
+namespace sandbox {
+
 namespace {
 
 // Set an environment variable that reflects the API version we expect from the
 // setuid sandbox. Old versions of the sandbox will ignore this.
 void SetSandboxAPIEnvironmentVariable(base::Environment* env) {
-  env->SetVar(sandbox::kSandboxEnvironmentApiRequest,
-              base::IntToString(sandbox::kSUIDSandboxApiNumber));
+  env->SetVar(kSandboxEnvironmentApiRequest,
+              base::IntToString(kSUIDSandboxApiNumber));
 }
 
 // Unset environment variables that are expected to be set by the setuid
 // sandbox. This is to allow nesting of one instance of the SUID sandbox
 // inside another.
 void UnsetExpectedEnvironmentVariables(base::EnvironmentMap* env_map) {
   DCHECK(env_map);
   const base::NativeEnvironmentString environment_vars[] = {
-      sandbox::kSandboxDescriptorEnvironmentVarName,
-      sandbox::kSandboxHelperPidEnvironmentVarName,
-      sandbox::kSandboxEnvironmentApiProvides,
-      sandbox::kSandboxPIDNSEnvironmentVarName,
-      sandbox::kSandboxNETNSEnvironmentVarName,
+      kSandboxDescriptorEnvironmentVarName, kSandboxHelperPidEnvironmentVarName,
+      kSandboxEnvironmentApiProvides,       kSandboxPIDNSEnvironmentVarName,
+      kSandboxNETNSEnvironmentVarName,
   };
 
   for (size_t i = 0; i < arraysize(environment_vars); ++i) {
     // Setting values in EnvironmentMap to an empty-string will make
     // sure that they get unset from the environment via AlterEnvironment().
     (*env_map)[environment_vars[i]] = base::NativeEnvironmentString();
   }
 }
 
 // Wrapper around a shared C function.
 // Returns the "saved" environment variable name corresponding to |envvar|
 // in a new string or NULL.
 std::string* CreateSavedVariableName(const char* env_var) {
   char* const saved_env_var = SandboxSavedEnvironmentVariable(env_var);
   if (!saved_env_var)
-    return NULL;
+    return nullptr;
   std::string* saved_env_var_copy = new std::string(saved_env_var);
   // SandboxSavedEnvironmentVariable is the C function that we wrap and uses
   // malloc() to allocate memory.
   free(saved_env_var);
   return saved_env_var_copy;
 }
 
 // The ELF loader will clear many environment variables so we save them to
 // different names here so that the SUID sandbox can resolve them for the
 // renderer.
 void SaveSUIDUnsafeEnvironmentVariables(base::Environment* env) {
   for (unsigned i = 0; kSUIDUnsafeEnvironmentVariables[i]; ++i) {
     const char* env_var = kSUIDUnsafeEnvironmentVariables[i];
     // Get the saved environment variable corresponding to envvar.
     std::unique_ptr<std::string> saved_env_var(
         CreateSavedVariableName(env_var));
-    if (saved_env_var == NULL)
+    if (!saved_env_var)
       continue;
 
     std::string value;
     if (env->GetVar(env_var, &value))
       env->SetVar(saved_env_var->c_str(), value);
     else
       env->UnSetVar(saved_env_var->c_str());
   }
 }
 
 const char* GetDevelSandboxPath() {
   return getenv("CHROME_DEVEL_SANDBOX");
 }
 
 }  // namespace
 
-namespace sandbox {
-
 SetuidSandboxHost* SetuidSandboxHost::Create() {
-  base::Environment* environment(base::Environment::Create());
-  CHECK(environment);
-  return new SetuidSandboxHost(environment);
+  return new SetuidSandboxHost(base::Environment::Create());
 }
 
-SetuidSandboxHost::SetuidSandboxHost(base::Environment* env) : env_(env) {
+SetuidSandboxHost::SetuidSandboxHost(std::unique_ptr<base::Environment> env)
+    : env_(std::move(env)) {
+  DCHECK(env_);
 }
 
 SetuidSandboxHost::~SetuidSandboxHost() {
 }
 
 // Check if CHROME_DEVEL_SANDBOX is set but empty. This currently disables
 // the setuid sandbox. TODO(jln): fix this (crbug.com/245376).
 bool SetuidSandboxHost::IsDisabledViaEnvironment() {
   const char* devel_sandbox_path = GetDevelSandboxPath();
-  if (devel_sandbox_path && '\0' == *devel_sandbox_path) {
-    return true;
-  }
-  return false;
+  return devel_sandbox_path && (*devel_sandbox_path == '\0');
 }
 
 base::FilePath SetuidSandboxHost::GetSandboxBinaryPath() {
   base::FilePath sandbox_binary;
   base::FilePath exe_dir;
   if (PathService::Get(base::DIR_EXE, &exe_dir)) {
     base::FilePath sandbox_candidate = exe_dir.AppendASCII("chrome-sandbox");
     if (base::PathExists(sandbox_candidate))
       sandbox_binary = sandbox_candidate;
   }
@@ skipping 57 matching lines @@
   // kZygoteIdFd. Fixing this requires a sandbox API change. :(
   fds_to_remap->push_back(std::make_pair(dummy_fd->get(), kZygoteIdFd));
 }
 
 void SetuidSandboxHost::SetupLaunchEnvironment() {
   SaveSUIDUnsafeEnvironmentVariables(env_.get());
   SetSandboxAPIEnvironmentVariable(env_.get());
 }
 
 }  // namespace sandbox