Cross platform low level file IO wrappers

util/mach/exception_ports_test.cc

 // Copyright 2014 The Crashpad Authors. All rights reserved.
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
 // You may obtain a copy of the License at
 //
 //     http://www.apache.org/licenses/LICENSE-2.0
 //
 // Unless required by applicable law or agreed to in writing, software
 // distributed under the License is distributed on an "AS IS" BASIS,
 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
 #include "util/mach/exception_ports.h"
 
 #include <mach/mach.h>
 #include <pthread.h>
 #include <signal.h>
 #include <unistd.h>
 
 #include "base/basictypes.h"
 #include "base/logging.h"
 #include "base/mac/mach_logging.h"
 #include "base/mac/scoped_mach_port.h"
 #include "base/strings/stringprintf.h"
 #include "gtest/gtest.h"
-#include "util/file/fd_io.h"
+#include "util/file/file_io.h"
 #include "util/mach/exc_server_variants.h"
 #include "util/mach/mach_extensions.h"
 #include "util/mach/mach_message.h"
 #include "util/mach/mach_message_server.h"
 #include "util/misc/scoped_forbid_return.h"
 #include "util/synchronization/semaphore.h"
 #include "util/test/mac/mach_errors.h"
 #include "util/test/mac/mach_multiprocess.h"
 
 namespace crashpad {
@@ skipping 196 matching lines @@
       }
 
       int rv_int = pthread_create(&thread_, nullptr, ThreadMainThunk, this);
       ASSERT_EQ(0, rv_int);
 
       // Wait for the new thread to be ready.
       init_semaphore_.Wait();
 
       // Tell the parent process that everything is set up.
       char c = '\0';
-      CheckedWriteFD(test_exception_ports_->WritePipeFD(), &c, 1);
+      CheckedWriteFile(test_exception_ports_->WritePipeFD(), &c, 1);
 
       // Wait for the parent process to say that its end is set up.
-      CheckedReadFD(test_exception_ports_->ReadPipeFD(), &c, 1);
+      CheckedReadFile(test_exception_ports_->ReadPipeFD(), &c, 1);
       EXPECT_EQ('\0', c);
 
       // Regardless of where ExceptionPorts::SetExceptionPort() ran,
       // ExceptionPorts::GetExceptionPorts() can always be tested in-process.
       {
         SCOPED_TRACE("task");
         TestGetExceptionPorts(self_task_ports, remote_port, EXCEPTION_DEFAULT);
       }
 
       {
@@ skipping 93 matching lines @@
 
     DISALLOW_COPY_AND_ASSIGN(Child);
   };
 
   // MachMultiprocess:
 
   void MachMultiprocessParent() override {
     // Wait for the child process to be ready. It needs to have all of its
     // threads set up before proceeding if in kSetOutOfProcess mode.
     char c;
-    CheckedReadFD(ReadPipeFD(), &c, 1);
+    CheckedReadFile(ReadPipeFD(), &c, 1);
     EXPECT_EQ('\0', c);
 
     mach_port_t local_port = LocalPort();
 
     // Get an ExceptionPorts object for the task and each of its threads.
     ExceptionPorts task_ports(ExceptionPorts::kTargetTypeTask, ChildTask());
     EXPECT_EQ("task", task_ports.TargetTypeName());
 
     // Hopefully the threads returned by task_threads() are in order, with the
     // main thread first and the other thread second. This is currently always
@@ skipping 62 matching lines @@
 
     {
       SCOPED_TRACE("other_thread");
       TestGetExceptionPorts(
           other_thread_ports, thread_handler, EXCEPTION_STATE_IDENTITY);
     }
 
     // Let the child process know that everything in the parent process is set
     // up.
     c = '\0';
-    CheckedWriteFD(WritePipeFD(), &c, 1);
+    CheckedWriteFile(WritePipeFD(), &c, 1);
 
     if (who_crashes_ != kNobodyCrashes) {
       UniversalMachExcServer universal_mach_exc_server(this);
 
       kern_return_t kr =
           MachMessageServer::Run(&universal_mach_exc_server,
                                  local_port,
                                  MACH_MSG_OPTION_NONE,
                                  MachMessageServer::kOneShot,
                                  MachMessageServer::kReceiveLargeError,
                                  kMachMessageTimeoutWaitIndefinitely);
       EXPECT_EQ(KERN_SUCCESS, kr)
           << MachErrorMessage(kr, "MachMessageServer::Run");
 
       EXPECT_TRUE(handled_);
     }
 
     // Wait for the child process to exit or terminate, as indicated by it
     // closing its pipe. This keeps LocalPort() alive in the child as
     // RemotePort(), for the child’s use in its TestGetExceptionPorts().
-    CheckedReadFDAtEOF(ReadPipeFD());
+    CheckedReadFileAtEOF(ReadPipeFD());
   }
 
   void MachMultiprocessChild() override {
     Child child(this);
     child.Run();
   }
 
   SetType set_type_;
   SetOn set_on_;
   WhoCrashes who_crashes_;
@@ skipping 97 matching lines @@
   if (geteuid() == 0) {
     EXPECT_TRUE(rv);
   } else {
     EXPECT_FALSE(rv);
   }
 }
 
 }  // namespace
 }  // namespace test
 }  // namespace crashpad