refactor: move IOObject::m_should_close_fd into subclasses

[lawrence_danna]

Summary

m_should_close_fd doesn't need to be in IOObject. It will be useful
for my next change to move it down into File and Socket.

lldb/include/lldb/Host/File.h

enum OpenOptions {
     eOpenOptionDontFollowSymlinks = (1u << 7),
     eOpenOptionCloseOnExec =
         (1u << 8) // Close the file when executing a new process
   };
 
   static mode_t ConvertOpenOptionsForPOSIXOpen(uint32_t open_options);
 
   File()
-      : IOObject(eFDTypeFile, false), m_descriptor(kInvalidDescriptor),
-        m_stream(kInvalidStream), m_options(0), m_own_stream(false),
-        m_is_interactive(eLazyBoolCalculate),
+      : IOObject(eFDTypeFile), m_descriptor(kInvalidDescriptor),
+        m_own_descriptor(false), m_stream(kInvalidStream), m_options(0),
+        m_own_stream(false), m_is_interactive(eLazyBoolCalculate),
         m_is_real_terminal(eLazyBoolCalculate),
         m_supports_colors(eLazyBoolCalculate) {}
 
   File(FILE *fh, bool transfer_ownership)
-      : IOObject(eFDTypeFile, false), m_descriptor(kInvalidDescriptor),
-        m_stream(fh), m_options(0), m_own_stream(transfer_ownership),
-        m_is_interactive(eLazyBoolCalculate),
+      : IOObject(eFDTypeFile), m_descriptor(kInvalidDescriptor),
+        m_own_descriptor(false), m_stream(fh), m_options(0),
+        m_own_stream(transfer_ownership), m_is_interactive(eLazyBoolCalculate),
         m_is_real_terminal(eLazyBoolCalculate),
         m_supports_colors(eLazyBoolCalculate) {}
 
   File(int fd, uint32_t options, bool transfer_ownership)
-      : IOObject(eFDTypeFile, transfer_ownership), m_descriptor(fd),
-        m_stream(kInvalidStream), m_options(options), m_own_stream(false),
+      : IOObject(eFDTypeFile), m_descriptor(fd),
+        m_own_descriptor(transfer_ownership), m_stream(kInvalidStream),
+        m_options(options), m_own_stream(false),
         m_is_interactive(eLazyBoolCalculate),
         m_is_real_terminal(eLazyBoolCalculate) {}
 
   /// Destructor.
   ///
   /// The destructor is virtual in case this class is subclassed.
   ~File() override;
 
protected:
   bool DescriptorIsValid() const { return DescriptorIsValid(m_descriptor); }
 
   bool StreamIsValid() const { return m_stream != kInvalidStream; }
 
   void CalculateInteractiveAndTerminal();
 
   // Member variables
   int m_descriptor;
+  bool m_own_descriptor;
   FILE *m_stream;
   uint32_t m_options;
   bool m_own_stream;
   LazyBool m_is_interactive;
   LazyBool m_is_real_terminal;
   LazyBool m_supports_colors;
   std::mutex offset_access_mutex;
 
 private:
   DISALLOW_COPY_AND_ASSIGN(File);
 };
 
 } // namespace lldb_private
 
 #endif // liblldb_File_h_

lldb/include/lldb/Host/Socket.h

static NativeSocket CreateSocket(const int domain, const int type,
                                    bool child_processes_inherit, Status &error);
   static NativeSocket AcceptSocket(NativeSocket sockfd, struct sockaddr *addr,
                                    socklen_t *addrlen,
                                    bool child_processes_inherit, Status &error);
 
   SocketProtocol m_protocol;
   NativeSocket m_socket;
   bool m_child_processes_inherit;
+  bool m_should_close_fd;
 };
 
 } // namespace lldb_private
 
 #endif // liblldb_Host_Socket_h_

lldb/include/lldb/Utility/IOObject.h

enum FDType {
     eFDTypeSocket, // Socket requiring send/recv
   };
 
   // TODO: On Windows this should be a HANDLE, and wait should use
   // WaitForMultipleObjects
   typedef int WaitableHandle;
   static const WaitableHandle kInvalidHandleValue;
 
-  IOObject(FDType type, bool should_close)
-      : m_fd_type(type), m_should_close_fd(should_close) {}
+  IOObject(FDType type) : m_fd_type(type) {}
   virtual ~IOObject();
 
   virtual Status Read(void *buf, size_t &num_bytes) = 0;
   virtual Status Write(const void *buf, size_t &num_bytes) = 0;
   virtual bool IsValid() const = 0;
   virtual Status Close() = 0;
 
   FDType GetFdType() const { return m_fd_type; }
 
   virtual WaitableHandle GetWaitableHandle() = 0;
 
 protected:
   FDType m_fd_type;
-  bool m_should_close_fd; // True if this class should close the file descriptor
-                          // when it goes away.
 
 private:
   DISALLOW_COPY_AND_ASSIGN(IOObject);
 };
 } // namespace lldb_private
 
 #endif

lldb/source/Host/common/File.cpp

 
 IOObject::WaitableHandle File::GetWaitableHandle() { return GetDescriptor(); }
 
 FILE *File::GetStream() {
   if (!StreamIsValid()) {
     if (DescriptorIsValid()) {
       const char *mode = GetStreamOpenModeFromOptions(m_options);
       if (mode) {
-        if (!m_should_close_fd) {
+        if (!m_own_descriptor) {
 // We must duplicate the file descriptor if we don't own it because when you
 // call fdopen, the stream will own the fd
 #ifdef _WIN32
           m_descriptor = ::_dup(GetDescriptor());
 #else
           m_descriptor = dup(GetDescriptor());
 #endif
-          m_should_close_fd = true;
+          m_own_descriptor = true;
         }
 
         m_stream =
             llvm::sys::RetryAfterSignal(nullptr, ::fdopen, m_descriptor, mode);
 
         // If we got a stream, then we own the stream and should no longer own
         // the descriptor because fclose() will close it for us
 
         if (m_stream) {
           m_own_stream = true;
-          m_should_close_fd = false;
+          m_own_descriptor = false;
         }
       }
     }
   }
   return m_stream;
 }
 
 uint32_t File::GetPermissions(Status &error) const {

 
 Status File::Close() {
   Status error;
   if (StreamIsValid() && m_own_stream) {
     if (::fclose(m_stream) == EOF)
       error.SetErrorToErrno();
   }
 
-  if (DescriptorIsValid() && m_should_close_fd) {
+  if (DescriptorIsValid() && m_own_descriptor) {
     if (::close(m_descriptor) != 0)
       error.SetErrorToErrno();
   }
   m_descriptor = kInvalidDescriptor;
   m_stream = kInvalidStream;
   m_options = 0;
   m_own_stream = false;
-  m_should_close_fd = false;
+  m_own_descriptor = false;
   m_is_interactive = eLazyBoolCalculate;
   m_is_real_terminal = eLazyBoolCalculate;
   return error;
 }
 
 void File::Clear() {
   m_stream = nullptr;
   m_descriptor = kInvalidDescriptor;

lldb/source/Host/common/Socket.cpp

 #else
   return errno == EINTR;
 #endif
 }
 }
 
 Socket::Socket(SocketProtocol protocol, bool should_close,
                bool child_processes_inherit)
-    : IOObject(eFDTypeSocket, should_close), m_protocol(protocol),
+    : IOObject(eFDTypeSocket), m_protocol(protocol),
       m_socket(kInvalidSocketValue),
-      m_child_processes_inherit(child_processes_inherit) {}
+      m_child_processes_inherit(child_processes_inherit),
+      m_should_close_fd(should_close) {}
 
 Socket::~Socket() { Close(); }
 
 llvm::Error Socket::Initialize() {
 #if defined(_WIN32)
   auto wVersion = WINSOCK_VERSION;
   WSADATA wsaData;
   int err = ::WSAStartup(wVersion, &wsaData);