Cleanup: Remove base::environment_vector and base::file_handle_mapping_vector to StudlyCaps.

base/process_util_unittest.cc

 // 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.
 
 #define _CRT_SECURE_NO_WARNINGS
 
 #include <limits>
 
 #include "base/command_line.h"
 #include "base/eintr_wrapper.h"
@@ skipping 54 matching lines @@
 
 #if defined(OS_WIN)
 const int kExpectedStillRunningExitCode = 0x102;
 const int kExpectedKilledExitCode = 1;
 #else
 const int kExpectedStillRunningExitCode = 0;
 #endif
 
 // Sleeps until file filename is created.
 void WaitToDie(const char* filename) {
-  FILE *fp;
+  FILE* fp;
   do {
     base::PlatformThread::Sleep(base::TimeDelta::FromMilliseconds(10));
     fp = fopen(filename, "r");
   } while (!fp);
   fclose(fp);
 }
 
 // Signals children they should die now.
 void SignalChildren(const char* filename) {
-  FILE *fp = fopen(filename, "w");
+  FILE* fp = fopen(filename, "w");
   fclose(fp);
 }
 
 // Using a pipe to the child to wait for an event was considered, but
 // there were cases in the past where pipes caused problems (other
 // libraries closing the fds, child deadlocking). This is a simple
 // case, so it's not worth the risk.  Using wait loops is discouraged
 // in most instances.
 base::TerminationStatus WaitForChildTermination(base::ProcessHandle handle,
                                                 int* exit_code) {
@@ skipping 157 matching lines @@
   EXPECT_NE(0, signaled);
   int signal = WTERMSIG(exit_code);
   EXPECT_EQ(SIGSEGV, signal);
 #endif
   base::CloseProcessHandle(handle);
 
   // Reset signal handlers back to "normal".
   base::EnableInProcessStackDumping();
   remove(kSignalFileCrash);
 }
-#endif // !defined(OS_MACOSX)
+#endif  // !defined(OS_MACOSX)
 
 MULTIPROCESS_TEST_MAIN(KilledChildProcess) {
   WaitToDie(kSignalFileKill);
 #if defined(OS_WIN)
   // Kill ourselves.
   HANDLE handle = ::OpenProcess(PROCESS_ALL_ACCESS, 0, ::GetCurrentProcessId());
   ::TerminateProcess(handle, kExpectedKilledExitCode);
 #elif defined(OS_POSIX)
   // Send a SIGKILL to this process, just like the OOM killer would.
   ::kill(getpid(), SIGKILL);
@@ skipping 237 matching lines @@
   DPCHECK(ret == 0);
 
   return 0;
 }
 
 int ProcessUtilTest::CountOpenFDsInChild() {
   int fds[2];
   if (pipe(fds) < 0)
     NOTREACHED();
 
-  base::file_handle_mapping_vector fd_mapping_vec;
+  base::FileHandleMappingVector fd_mapping_vec;
   fd_mapping_vec.push_back(std::pair<int, int>(fds[1], kChildPipe));
   base::ProcessHandle handle = this->SpawnChild(
       "ProcessUtilsLeakFDChildProcess", fd_mapping_vec, false);
   CHECK(handle);
   int ret = HANDLE_EINTR(close(fds[1]));
   DPCHECK(ret == 0);
 
   // Read number of open files in client process from pipe;
   int num_open_files = -1;
   ssize_t bytes_read =
@@ skipping 25 matching lines @@
   ret = HANDLE_EINTR(close(sockets[0]));
   DPCHECK(ret == 0);
   ret = HANDLE_EINTR(close(sockets[1]));
   DPCHECK(ret == 0);
   ret = HANDLE_EINTR(close(dev_null));
   DPCHECK(ret == 0);
 }
 
 namespace {
 
-std::string TestLaunchProcess(const base::environment_vector& env_changes,
+std::string TestLaunchProcess(const base::EnvironmentVector& env_changes,
                               const int clone_flags) {
   std::vector<std::string> args;
-  base::file_handle_mapping_vector fds_to_remap;
+  base::FileHandleMappingVector fds_to_remap;
 
   args.push_back(kPosixShell);
   args.push_back("-c");
   args.push_back("echo $BASE_TEST");
 
   int fds[2];
   PCHECK(pipe(fds) == 0);
 
   fds_to_remap.push_back(std::make_pair(fds[1], 1));
   base::LaunchOptions options;
@@ skipping 22 matching lines @@
     "0123456789012345678901234567890123456789012345678901234567890123456789"
     "0123456789012345678901234567890123456789012345678901234567890123456789"
     "0123456789012345678901234567890123456789012345678901234567890123456789"
     "0123456789012345678901234567890123456789012345678901234567890123456789"
     "0123456789012345678901234567890123456789012345678901234567890123456789"
     "0123456789012345678901234567890123456789012345678901234567890123456789";
 
 }  // namespace
 
 TEST_F(ProcessUtilTest, LaunchProcess) {
-  base::environment_vector env_changes;
+  base::EnvironmentVector env_changes;
   const int no_clone_flags = 0;
 
   env_changes.push_back(std::make_pair(std::string("BASE_TEST"),
                                        std::string("bar")));
   EXPECT_EQ("bar\n", TestLaunchProcess(env_changes, no_clone_flags));
   env_changes.clear();
 
   EXPECT_EQ(0, setenv("BASE_TEST", "testing", 1 /* override */));
   EXPECT_EQ("testing\n", TestLaunchProcess(env_changes, no_clone_flags));
 
@@ skipping 18 matching lines @@
   // Don't test on Valgrind as it has limited support for clone().
   if (!RunningOnValgrind()) {
     EXPECT_EQ("wibble\n", TestLaunchProcess(env_changes, CLONE_FS | SIGCHLD));
   }
 #endif
 }
 
 TEST_F(ProcessUtilTest, AlterEnvironment) {
   const char* const empty[] = { NULL };
   const char* const a2[] = { "A=2", NULL };
-  base::environment_vector changes;
+  base::EnvironmentVector changes;
   char** e;
 
   e = base::AlterEnvironment(changes, empty);
   EXPECT_TRUE(e[0] == NULL);
   delete[] e;
 
   changes.push_back(std::make_pair(std::string("A"), std::string("1")));
   e = base::AlterEnvironment(changes, empty);
   EXPECT_EQ(std::string("A=1"), e[0]);
   EXPECT_TRUE(e[1] == NULL);
@@ skipping 487 matching lines @@
       SetUpInDeathAssert();
       while ((value_ = base::AllocatePsychoticallyBigObjCObject())) {}
     }, "");
 }
 
 #endif  // !ARCH_CPU_64_BITS
 #endif  // OS_MACOSX
 
 #endif  // !defined(OS_ANDROID) && !defined(OS_OPENBSD) &&
         // !defined(OS_WIN) && !defined(ADDRESS_SANITIZER)