Cross platform low level file IO wrappers

util/mach/mach_message_server_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/mach_message_server.h"
 
 #include <mach/mach.h>
 #include <string.h>
 
 #include <set>
 
 #include "base/basictypes.h"
 #include "base/mac/scoped_mach_port.h"
 #include "gtest/gtest.h"
-#include "util/file/fd_io.h"
+#include "util/file/file_io.h"
 #include "util/mach/mach_extensions.h"
 #include "util/mach/mach_message.h"
 #include "util/test/mac/mach_errors.h"
 #include "util/test/mac/mach_multiprocess.h"
 
 namespace crashpad {
 namespace test {
 namespace {
 
 class TestMachMessageServer : public MachMessageServer::Interface,
@@ skipping 292 matching lines @@
                                     MACH_PORT_LIMITS_INFO,
                                     reinterpret_cast<mach_port_info_t>(&limits),
                                     MACH_PORT_LIMITS_INFO_COUNT);
       ASSERT_EQ(KERN_SUCCESS, kr)
           << MachErrorMessage(kr, "mach_port_set_attributes");
     }
 
     if (options_.child_wait_for_parent_pipe_early) {
       // Tell the child to begin sending messages.
       char c = '\0';
-      CheckedWriteFD(WritePipeFD(), &c, 1);
+      CheckedWriteFile(WritePipeFD(), &c, 1);
     }
 
     if (options_.parent_wait_for_child_pipe) {
       // Wait until the child is done sending what it’s going to send.
       char c;
-      CheckedReadFD(ReadPipeFD(), &c, 1);
+      CheckedReadFile(ReadPipeFD(), &c, 1);
       EXPECT_EQ('\0', c);
     }
 
     ASSERT_EQ(options_.expect_server_result,
               (kr = MachMessageServer::Run(this,
                                            local_port,
                                            options_.server_options,
                                            options_.server_persistent,
                                            options_.server_receive_large,
                                            options_.server_timeout_ms)))
@@ skipping 24 matching lines @@
       // this test environment.
       kr = mach_port_type(
           mach_task_self(), parent_complex_message_port_, &type);
       EXPECT_EQ(KERN_INVALID_NAME, kr)
           << MachErrorMessage(kr, "mach_port_type");
     }
 
     if (options_.child_wait_for_parent_pipe_late) {
       // Let the child know it’s safe to exit.
       char c = '\0';
-      CheckedWriteFD(WritePipeFD(), &c, 1);
+      CheckedWriteFile(WritePipeFD(), &c, 1);
     }
   }
 
   void MachMultiprocessChild() override {
     if (options_.child_wait_for_parent_pipe_early) {
       // Wait until the parent is done setting things up on its end.
       char c;
-      CheckedReadFD(ReadPipeFD(), &c, 1);
+      CheckedReadFile(ReadPipeFD(), &c, 1);
       EXPECT_EQ('\0', c);
     }
 
     for (size_t index = 0;
          index < options_.client_send_request_count;
          ++index) {
       if (options_.child_send_all_requests_before_receiving_any_replies) {
         // For this test, all of the messages need to go into the queue before
         // the parent is allowed to start processing them. Don’t attempt to
         // process replies before all of the requests are sent, because the
@@ skipping 13 matching lines @@
 
       for (size_t index = 0;
            index < options_.client_send_request_count;
            ++index) {
         ASSERT_NO_FATAL_FAILURE(ChildWaitForReply());
       }
     }
 
     if (options_.child_wait_for_parent_pipe_late) {
       char c;
-      CheckedReadFD(ReadPipeFD(), &c, 1);
+      CheckedReadFile(ReadPipeFD(), &c, 1);
       ASSERT_EQ('\0', c);
     }
   }
 
   // In the child process, sends a request message to the server.
   void ChildSendRequest() {
     // local_receive_port_owner will the receive right that is created in this
     // scope and intended to be destroyed when leaving this scope, after it has
     // been carried in a Mach message.
     base::mac::ScopedMachReceiveRight local_receive_port_owner;
@@ skipping 107 matching lines @@
 
     ++replies_;
   }
 
   // For test types where the child needs to notify the server in the parent
   // that the child is ready, this method will send a byte via the POSIX pipe.
   // The parent will be waiting in a read() on this pipe, and will proceed to
   // running MachMessageServer() once it’s received.
   void ChildNotifyParentViaPipe() {
     char c = '\0';
-    CheckedWriteFD(WritePipeFD(), &c, 1);
+    CheckedWriteFile(WritePipeFD(), &c, 1);
   }
 
   // In the child process, sends a request message to the server and then
   // receives a reply message.
   void ChildSendRequestAndWaitForReply() {
     ASSERT_NO_FATAL_FAILURE(ChildSendRequest());
 
     if (options_.parent_wait_for_child_pipe &&
         !options_.child_send_all_requests_before_receiving_any_replies) {
       // The parent is waiting to read a byte to indicate that the message has
@@ skipping 280 matching lines @@
   options.expect_server_transaction_count = 0;
   options.client_send_large = true;
   options.client_expect_reply = false;
   TestMachMessageServer test_mach_message_server(options);
   test_mach_message_server.Test();
 }
 
 }  // namespace
 }  // namespace test
 }  // namespace crashpad