Stop casting uintptr_t* to int*.

base/files/file_path_watcher_kqueue.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.
 
 #include "base/files/file_path_watcher.h"
 
 #include <fcntl.h>
 #include <sys/event.h>
 #include <sys/param.h>
 
@@ skipping 76 matching lines @@
   // Returns true if the kevent values are error free.
   bool AreKeventValuesValid(struct kevent* kevents, int count);
 
   // Respond to a change of attributes of the path component represented by
   // |event|. Sets |target_file_affected| to true if |target_| is affected.
   // Sets |update_watches| to true if |events_| need to be updated.
   void HandleAttributesChange(const EventVector::iterator& event,
                               bool* target_file_affected,
                               bool* update_watches);
 
-  // Respond to a move of deletion of the path component represented by
+  // Respond to a move or deletion of the path component represented by
   // |event|. Sets |target_file_affected| to true if |target_| is affected.
   // Sets |update_watches| to true if |events_| need to be updated.
   void HandleDeleteOrMoveChange(const EventVector::iterator& event,
                                 bool* target_file_affected,
                                 bool* update_watches);
 
   // Respond to a creation of an item in the path component represented by
   // |event|. Sets |target_file_affected| to true if |target_| is affected.
   // Sets |update_watches| to true if |events_| need to be updated.
   void HandleCreateItemChange(const EventVector::iterator& event,
                               bool* target_file_affected,
                               bool* update_watches);
 
   // Update |events_| with the current status of the system.
   // Sets |target_file_affected| to true if |target_| is affected.
   // Returns false if an error occurs.
   bool UpdateWatches(bool* target_file_affected);
 
   // Fills |events| with one kevent per component in |path|.
   // Returns the number of valid events created where a valid event is
   // defined as one that has a ident (file descriptor) field != -1.
   static int EventsForPath(FilePath path, EventVector *events);
 
   // Release a kevent generated by EventsForPath.
   static void ReleaseEvent(struct kevent& event);
 
   // Returns a file descriptor that will not block the system from deleting
   // the file it references.
-  static int FileDescriptorForPath(const FilePath& path);
+  static uintptr_t FileDescriptorForPath(const FilePath& path);
+
+  static const uintptr_t kNoFileDescriptor = static_cast<uintptr_t>(-1);
 
   // Closes |*fd| and sets |*fd| to -1.
-  static void CloseFileDescriptor(int* fd);
+  static void CloseFileDescriptor(uintptr_t* fd);
 
   // Returns true if kevent has open file descriptor.
   static bool IsKeventFileDescriptorOpen(const struct kevent& event) {
-    return event.ident != static_cast<uintptr_t>(-1);
+    return event.ident != kNoFileDescriptor;
   }
 
   static EventData* EventDataForKevent(const struct kevent& event) {
     return reinterpret_cast<EventData*>(event.udata);
   }
 
   EventVector events_;
   scoped_refptr<base::MessageLoopProxy> io_message_loop_;
   MessageLoopForIO::FileDescriptorWatcher kqueue_watcher_;
   FilePathWatcher::Callback callback_;
   FilePath target_;
   int kqueue_;
 
   DISALLOW_COPY_AND_ASSIGN(FilePathWatcherImpl);
 };
 
 void FilePathWatcherImpl::ReleaseEvent(struct kevent& event) {
-  CloseFileDescriptor(reinterpret_cast<int*>(&event.ident));
+  CloseFileDescriptor(&event.ident);
   EventData* entry = EventDataForKevent(event);
   delete entry;
   event.udata = NULL;
 }
 
 int FilePathWatcherImpl::EventsForPath(FilePath path, EventVector* events) {
   DCHECK(MessageLoopForIO::current());
   // Make sure that we are working with a clean slate.
   DCHECK(events->empty());
 
   std::vector<FilePath::StringType> components;
   path.GetComponents(&components);
 
   if (components.size() < 1) {
     return -1;
   }
 
   int last_existing_entry = 0;
   FilePath built_path;
   bool path_still_exists = true;
   for(std::vector<FilePath::StringType>::iterator i = components.begin();
       i != components.end(); ++i) {
     if (i == components.begin()) {
       built_path = FilePath(*i);
     } else {
       built_path = built_path.Append(*i);
     }
-    int fd = -1;
+    uintptr_t fd = kNoFileDescriptor;
     if (path_still_exists) {
       fd = FileDescriptorForPath(built_path);
-      if (fd == -1) {
+      if (fd == kNoFileDescriptor) {
         path_still_exists = false;
       } else {
         ++last_existing_entry;
       }
     }
     FilePath::StringType subdir = (i != (components.end() - 1)) ? *(i + 1) : "";
     EventData* data = new EventData(built_path, subdir);
     struct kevent event;
     EV_SET(&event, fd, EVFILT_VNODE, (EV_ADD | EV_CLEAR | EV_RECEIPT),
            (NOTE_DELETE | NOTE_WRITE | NOTE_ATTRIB |
             NOTE_RENAME | NOTE_REVOKE | NOTE_EXTEND), 0, data);
     events->push_back(event);
   }
   return last_existing_entry;
 }
 
-int FilePathWatcherImpl::FileDescriptorForPath(const FilePath& path) {
-  return HANDLE_EINTR(open(path.value().c_str(), O_EVTONLY));
+uintptr_t FilePathWatcherImpl::FileDescriptorForPath(const FilePath& path) {
+  int fd = HANDLE_EINTR(open(path.value().c_str(), O_EVTONLY));
+  if (fd == -1)
+    return kNoFileDescriptor;
+  return fd;
 }
 
-void FilePathWatcherImpl::CloseFileDescriptor(int *fd) {
-  if (*fd == -1) {
+void FilePathWatcherImpl::CloseFileDescriptor(uintptr_t* fd) {
+  if (*fd == kNoFileDescriptor) {
     return;
   }
 
   if (HANDLE_EINTR(close(*fd)) != 0) {
     DPLOG(ERROR) << "close";
   }
-  *fd = -1;
+  *fd = kNoFileDescriptor;
 }
 
 bool FilePathWatcherImpl::AreKeventValuesValid(struct kevent* kevents,
                                                int count) {
   if (count < 0) {
     DPLOG(ERROR) << "kevent";
     return false;
   }
   bool valid = true;
   for (int i = 0; i < count; ++i) {
     if (kevents[i].flags & EV_ERROR && kevents[i].data) {
       // Find the kevent in |events_| that matches the kevent with the error.
       EventVector::iterator event = events_.begin();
       for (; event != events_.end(); ++event) {
         if (event->ident == kevents[i].ident) {
           break;
         }
       }
       std::string path_name;
       if (event != events_.end()) {
         EventData* event_data = EventDataForKevent(*event);
         if (event_data != NULL) {
           path_name = event_data->path_.value();
         }
       }
       if (path_name.empty()) {
         path_name = base::StringPrintf(
-            "fd %d", *reinterpret_cast<int*>(&kevents[i].ident));
+            "fd %ld", reinterpret_cast<long>(&kevents[i].ident));
       }
       DLOG(ERROR) << "Error: " << kevents[i].data << " for " << path_name;
       valid = false;
     }
   }
   return valid;
 }
 
 void FilePathWatcherImpl::HandleAttributesChange(
     const EventVector::iterator& event,
     bool* target_file_affected,
     bool* update_watches) {
   EventVector::iterator next_event = event + 1;
   EventData* next_event_data = EventDataForKevent(*next_event);
   // Check to see if the next item in path is still accessible.
-  int have_access = FileDescriptorForPath(next_event_data->path_);
-  if (have_access == -1) {
+  uintptr_t have_access = FileDescriptorForPath(next_event_data->path_);
+  if (have_access == kNoFileDescriptor) {
     *target_file_affected = true;
     *update_watches = true;
     EventVector::iterator local_event(event);
     for (; local_event != events_.end(); ++local_event) {
       // Close all nodes from the event down. This has the side effect of
       // potentially rendering other events in |updates| invalid.
       // There is no need to remove the events from |kqueue_| because this
       // happens as a side effect of closing the file descriptor.
-      CloseFileDescriptor(reinterpret_cast<int*>(&local_event->ident));
+      CloseFileDescriptor(&local_event->ident);
     }
   } else {
     CloseFileDescriptor(&have_access);
   }
 }
 
 void FilePathWatcherImpl::HandleDeleteOrMoveChange(
     const EventVector::iterator& event,
     bool* target_file_affected,
     bool* update_watches) {
   *target_file_affected = true;
   *update_watches = true;
   EventVector::iterator local_event(event);
   for (; local_event != events_.end(); ++local_event) {
     // Close all nodes from the event down. This has the side effect of
     // potentially rendering other events in |updates| invalid.
     // There is no need to remove the events from |kqueue_| because this
     // happens as a side effect of closing the file descriptor.
-    CloseFileDescriptor(reinterpret_cast<int*>(&local_event->ident));
+    CloseFileDescriptor(&local_event->ident);
   }
 }
 
 void FilePathWatcherImpl::HandleCreateItemChange(
     const EventVector::iterator& event,
     bool* target_file_affected,
     bool* update_watches) {
   // Get the next item in the path.
   EventVector::iterator next_event = event + 1;
-  EventData* next_event_data = EventDataForKevent(*next_event);
-
   // Check to see if it already has a valid file descriptor.
   if (!IsKeventFileDescriptorOpen(*next_event)) {
+    EventData* next_event_data = EventDataForKevent(*next_event);
     // If not, attempt to open a file descriptor for it.
     next_event->ident = FileDescriptorForPath(next_event_data->path_);
     if (IsKeventFileDescriptorOpen(*next_event)) {
       *update_watches = true;
       if (next_event_data->subdir_.empty()) {
         *target_file_affected = true;
       }
     }
   }
 }
@@ skipping 66 matching lines @@
   // Iterate through each of the updates and react to them.
   for (int i = 0; i < count; ++i) {
     // Find our kevent record that matches the update notification.
     EventVector::iterator event = events_.begin();
     for (; event != events_.end(); ++event) {
       if (!IsKeventFileDescriptorOpen(*event) ||
           event->ident == updates[i].ident) {
         break;
       }
     }
-    if (!IsKeventFileDescriptorOpen(*event) || event == events_.end()) {
+    if (event == events_.end() || !IsKeventFileDescriptorOpen(*event)) {
       // The event may no longer exist in |events_| because another event
       // modified |events_| in such a way to make it invalid. For example if
       // the path is /foo/bar/bam and foo is deleted, NOTE_DELETE events for
       // foo, bar and bam will be sent. If foo is processed first, then
       // the file descriptors for bar and bam will already be closed and set
       // to -1 before they get a chance to be processed.
       continue;
     }
 
     EventData* event_data = EventDataForKevent(*event);
@@ skipping 91 matching lines @@
     return;
   }
   CancelOnMessageLoopThread();
 }
 
 void FilePathWatcherImpl::CancelOnMessageLoopThread() {
   DCHECK(MessageLoopForIO::current());
   if (!is_cancelled()) {
     set_cancelled();
     kqueue_watcher_.StopWatchingFileDescriptor();
-    CloseFileDescriptor(&kqueue_);
+    if (HANDLE_EINTR(close(kqueue_)) != 0) {
+      DPLOG(ERROR) << "close kqueue";
+    }
+    kqueue_ = -1;
     std::for_each(events_.begin(), events_.end(), ReleaseEvent);
     events_.clear();
     io_message_loop_ = NULL;
     MessageLoop::current()->RemoveDestructionObserver(this);
     callback_.Reset();
   }
 }
 
 }  // namespace
 
 FilePathWatcher::FilePathWatcher() {
   impl_ = new FilePathWatcherImpl();
 }
 
 }  // namespace base