base: Remove the string logging from CHECK().

remoting/host/linux/remoting_user_session.cc

 // Copyright 2016 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.
 //
 // This file implements a wrapper to run the virtual me2me session within a
 // proper PAM session. It will generally be run as root and drop privileges to
 // the specified user before running the me2me session script.
 
 #include <sys/types.h>
 #include <sys/stat.h>
@@ skipping 235 matching lines @@
 // Runs the me2me script in a PAM session. Exits the program on failure.
 // If chown_log is true, the owner and group of the file associated with stdout
 // will be changed to the target user.
 void ExecuteSession(std::string user, base::StringPiece script_path,
                     bool chown_log) {
   //////////////////////////////////////////////////////////////////////////////
   // Set up the PAM session
   //////////////////////////////////////////////////////////////////////////////
 
   PamHandle pam_handle(kPamName, user.c_str(), &kPamConversation);
-  CHECK(pam_handle.IsInitialized()) << "Failed to initialize PAM";
+  // Failed to initialize PAM
+  CHECK(pam_handle.IsInitialized());
 
   // Make sure the account is valid and enabled.
   pam_handle.CheckReturnCode(pam_handle.AccountManagement(0), "Account check");
 
   // PAM may remap the user at any stage.
   user = pam_handle.GetUser().value_or(std::move(user));
 
   // setcred explicitly does not handle group membership, and specifies that
   // group membership should be established before calling setcred. PAM modules
   // may also use getpwnam, so pwinfo can only be assumed valid until the next
   // PAM call.
   errno = 0;
   struct passwd* pwinfo = getpwnam(user.c_str());
-  PCHECK(pwinfo != nullptr) << "getpwnam failed";
-  PCHECK(setgid(pwinfo->pw_gid) == 0) << "setgid failed";
-  PCHECK(initgroups(pwinfo->pw_name, pwinfo->pw_gid) == 0)
-      << "initgroups failed";
+  // getpwnam failed
+  CHECK(pwinfo != nullptr);
+  // setgid failed
+  CHECK(setgid(pwinfo->pw_gid) == 0);
+  // initgroups failed
+  CHECK(initgroups(pwinfo->pw_name, pwinfo->pw_gid) == 0);
 
   // The documentation states that setcred should be called before open_session,
   // as done here, but it may be worth noting that `login` calls open_session
   // first.
   pam_handle.CheckReturnCode(pam_handle.SetCredentials(PAM_ESTABLISH_CRED),
                               "Set credentials");
 
   pam_handle.CheckReturnCode(pam_handle.OpenSession(0), "Open session");
 
   // The above may have remapped the user.
   user =  pam_handle.GetUser().value_or(std::move(user));
 
   base::Optional<base::EnvironmentMap> pam_environment =
       pam_handle.GetEnvironment();
-  CHECK(pam_environment) << "Failed to get environment from PAM";
+  // Failed to get environment from PAM
+  CHECK(pam_environment);
 
   //////////////////////////////////////////////////////////////////////////////
   // Prepare to execute remoting session process
   //////////////////////////////////////////////////////////////////////////////
 
   // Callback to be run in child process after fork and before exec.
   // chdir is called manually instead of using LaunchOptions.current_directory
   // because it should take place after setuid. (This both makes sure the user
   // has the proper permissions and also apparently avoids some obscure errors
   // that can occur when accessing some network filesystems as the wrong user.)
   class PreExecDelegate : public base::LaunchOptions::PreExecDelegate {
    public:
     void RunAsyncSafe() override {
       // Use RAW_CHECK to avoid allocating post-fork.
       RAW_CHECK(setuid(pwinfo_->pw_uid) == 0);
       RAW_CHECK(chdir(pwinfo_->pw_dir) == 0);
     }
 
     PreExecDelegate(struct passwd* pwinfo) : pwinfo_(pwinfo) {}
 
    private:
     struct passwd* pwinfo_;
   };
 
   // Fetch pwinfo again, as it may have been invalidated or the user name might
   // have been remapped.
   pwinfo = getpwnam(user.c_str());
-  PCHECK(pwinfo != nullptr) << "getpwnam failed";
+  // getpwnam failed
+  CHECK(pwinfo != nullptr);
 
   if (chown_log) {
     int result = fchown(STDOUT_FILENO, pwinfo->pw_uid, pwinfo->pw_gid);
     PLOG_IF(WARNING, result != 0) << "Failed to change log file owner";
   }
 
   PreExecDelegate pre_exec_delegate(pwinfo);
 
   base::LaunchOptions launch_options;
 
@@ skipping 15 matching lines @@
   launch_options.pre_exec_delegate = &pre_exec_delegate;
 
   // By convention, a login shell is signified by preceeding the shell name in
   // argv[0] with a '-'.
   base::CommandLine command_line(base::FilePath(
       '-' + base::FilePath(pwinfo->pw_shell).BaseName().value()));
 
   base::Optional<std::string> escaped_script_path =
       ShellEscapeArgument(script_path);
 
-  CHECK(escaped_script_path) << "Could not escape script path";
+  // Could not escape script path
+  CHECK(escaped_script_path);
 
   command_line.AppendSwitch("-c");
   command_line.AppendArg(*escaped_script_path +
                          " --start --foreground --keep-parent-env");
 
   // Tell LaunchProcess where to find the executable, since argv[0] doesn't
   // point to it.
   launch_options.real_path = base::FilePath(pwinfo->pw_shell);
 
   //////////////////////////////////////////////////////////////////////////////
   // We're ready to execute the remoting session
   //////////////////////////////////////////////////////////////////////////////
 
   base::Process child = base::LaunchProcess(command_line, launch_options);
 
   if (child.IsValid()) {
     int exit_code = 0;
     // Die if wait fails so we don't close the PAM session while the child is
     // still running.
-    CHECK(child.WaitForExit(&exit_code)) << "Failed to wait for child process";
+    // Failed to wait for child process
+    CHECK(child.WaitForExit(&exit_code));
     LOG_IF(WARNING, exit_code != 0) << "Child did not exit normally";
   }
 
   // Best effort PAM cleanup
   if (pam_handle.CloseSession(0) != PAM_SUCCESS) {
     LOG(WARNING) << "Failed to close PAM session";
   }
   ignore_result(pam_handle.SetCredentials(PAM_DELETE_CRED));
 }
 
@@ skipping 95 matching lines @@
     std::fputs("The target user must be specified.\n", stderr);
     std::exit(EXIT_FAILURE);
   }
 
   if (!foreground) {
     Daemonize();
   }
 
   ExecuteSession(std::move(user), script_path.value(), !foreground);
 }