Fixed lint errors caused by "runtime/references" rule and the rule itself is restored.

src/d8-posix.cc

 // Copyright 2009 the V8 project 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 <stdlib.h>
 #include <errno.h>
 #include <sys/types.h>
 #include <sys/stat.h>
 #include <sys/time.h>
@@ skipping 65 matching lines @@
   }
   return 0;
 }
 
 
 // Suspends the thread until there is data available from the child process.
 // Returns false on timeout, true on data ready.
 static bool WaitOnFD(int fd,
                      int read_timeout,
                      int total_timeout,
-                     struct timeval& start_time) {
+                     const struct timeval& start_time) {
   fd_set readfds, writefds, exceptfds;
   struct timeval timeout;
   int gone = 0;
   if (total_timeout != -1) {
     struct timeval time_now;
     gettimeofday(&time_now, NULL);
     int seconds = time_now.tv_sec - start_time.tv_sec;
     gone = seconds * 1000 + (time_now.tv_usec - start_time.tv_usec) / 1000;
     if (gone >= total_timeout) return false;
   }
@@ skipping 102 matching lines @@
   ~ExecArgs() {
     for (unsigned i = 0; i < kMaxArgs; i++) {
       if (exec_args_[i] == NULL) {
         return;
       }
       delete [] exec_args_[i];
       exec_args_[i] = 0;
     }
   }
   static const unsigned kMaxArgs = 1000;
-  char** arg_array() { return exec_args_; }
-  char* arg0() { return exec_args_[0]; }
+  char* const* arg_array() const { return exec_args_; }
+  const char* arg0() const { return exec_args_[0]; }
 
  private:
   char* exec_args_[kMaxArgs + 1];
 };
 
 
 // Gets the optional timeouts from the arguments to the system() call.
 static bool GetTimeouts(const v8::FunctionCallbackInfo<v8::Value>& args,
                         int* read_timeout,
                         int* total_timeout) {
@@ skipping 21 matching lines @@
 
 static const int kReadFD = 0;
 static const int kWriteFD = 1;
 
 
 // This is run in the child process after fork() but before exec().  It normally
 // ends with the child process being replaced with the desired child program.
 // It only returns if an error occurred.
 static void ExecSubprocess(int* exec_error_fds,
                            int* stdout_fds,
-                           ExecArgs& exec_args) {
+                           const ExecArgs& exec_args) {
   close(exec_error_fds[kReadFD]);  // Don't need this in the child.
   close(stdout_fds[kReadFD]);      // Don't need this in the child.
   close(1);                        // Close stdout.
   dup2(stdout_fds[kWriteFD], 1);   // Dup pipe fd to stdout.
   close(stdout_fds[kWriteFD]);     // Don't need the original fd now.
   fcntl(exec_error_fds[kWriteFD], F_SETFD, FD_CLOEXEC);
   execvp(exec_args.arg0(), exec_args.arg_array());
   // Only get here if the exec failed.  Write errno to the parent to tell
   // them it went wrong.  If it went well the pipe is closed.
   int err = errno;
@@ skipping 18 matching lines @@
     return false;
   }
   return true;
 }
 
 
 // Accumulates the output from the child in a string handle.  Returns true if it
 // succeeded or false if an exception was thrown.
 static Handle<Value> GetStdout(Isolate* isolate,
                                int child_fd,
-                               struct timeval& start_time,
+                               const struct timeval& start_time,
                                int read_timeout,
                                int total_timeout) {
   Handle<String> accumulator = String::Empty(isolate);
 
   int fullness = 0;
   static const int kStdoutReadBufferSize = 4096;
   char buffer[kStdoutReadBufferSize];
 
   if (fcntl(child_fd, F_SETFL, O_NONBLOCK) != 0) {
     return isolate->ThrowException(
@@ skipping 51 matching lines @@
     && !defined(__NetBSD__)
 #if !defined(__FreeBSD__)
 #define HAS_WAITID 1
 #endif
 #endif
 
 
 // Get exit status of child.
 static bool WaitForChild(Isolate* isolate,
                          int pid,
-                         ZombieProtector& child_waiter,
-                         struct timeval& start_time,
+                         ZombieProtector& child_waiter,  // NOLINT
+                         const struct timeval& start_time,
                          int read_timeout,
                          int total_timeout) {
 #ifdef HAS_WAITID
 
   siginfo_t child_info;
   child_info.si_pid = 0;
   int useconds = 1;
   // Wait for child to exit.
   while (child_info.si_pid == 0) {
     waitid(P_PID, pid, &child_info, WEXITED | WNOHANG | WNOWAIT);
@@ skipping 334 matching lines @@
                 FunctionTemplate::New(isolate, UnsetEnvironment));
   os_templ->Set(String::NewFromUtf8(isolate, "umask"),
                 FunctionTemplate::New(isolate, SetUMask));
   os_templ->Set(String::NewFromUtf8(isolate, "mkdirp"),
                 FunctionTemplate::New(isolate, MakeDirectory));
   os_templ->Set(String::NewFromUtf8(isolate, "rmdir"),
                 FunctionTemplate::New(isolate, RemoveDirectory));
 }
 
 }  // namespace v8