Implement file_util::CountFilesCreatedAfter() for posix environments....

base/file_util_posix.cc

 // Copyright (c) 2006-2008 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/file_util.h"
 
+#include <dirent.h>
 #include <errno.h>
 #include <fcntl.h>
 #include <fnmatch.h>
 #include <fts.h>
 #include <libgen.h>
 #include <stdio.h>
 #include <string.h>
 #include <sys/errno.h>
 #include <sys/mman.h>
 #include <sys/stat.h>
+#include <sys/types.h>
 #include <time.h>
+#include <unistd.h>
 
 #include <fstream>
 
 #include "base/basictypes.h"
 #include "base/file_path.h"
 #include "base/logging.h"
 #include "base/string_util.h"
+#include "base/time.h"
 
 namespace file_util {
 
 #if defined(GOOGLE_CHROME_BUILD)
 static const char* kTempFileName = "com.google.chrome.XXXXXX";
 #else
 static const char* kTempFileName = "org.chromium.XXXXXX";
 #endif
 
 std::wstring GetDirectoryFromPath(const std::wstring& path) {
   if (EndsWithSeparator(path)) {
     std::wstring dir = path;
     TrimTrailingSeparator(&dir);
     return dir;
   } else {
     char full_path[PATH_MAX];
     base::strlcpy(full_path, WideToUTF8(path).c_str(), arraysize(full_path));
     return UTF8ToWide(dirname(full_path));
   }
 }
 
 bool AbsolutePath(FilePath* path) {
   char full_path[PATH_MAX];
   if (realpath(path->value().c_str(), full_path) == NULL)
     return false;
   *path = FilePath(full_path);
   return true;
 }
 
+int CountFilesCreatedAfter(const FilePath& path,
+                           const base::Time& comparison_time) {
+  int file_count = 0;
+
+  DIR* dir = opendir(path.value().c_str());
+  if (dir) {
+    struct dirent* ent;
+    while ((ent = readdir(dir)) != NULL) {

[Erik does not do reviews, 2009/04/21 16:10:21]

lint says to use readdir_r instead of readdir (see the error column on the
rietvelg front page for this review)

+      if ((strcmp(ent->d_name, ".") == 0) ||
+          (strcmp(ent->d_name, "..") == 0))
+        continue;
+
+      struct stat64 st;
+      int test = stat64(path.Append(ent->d_name).value().c_str(), &st);
+      if (test != 0) {
+        LOG(ERROR) << "stat64 failed: " << strerror(errno);
+        continue;
+      }
+      if (st.st_ctime >= comparison_time.ToTimeT())

[Hironori Bono, 2009/04/22 04:46:27]

nit: If I recall correctly, base::Time::ToTimeT() discards microseconds from
|comparison_time|, i.e. |comparison_time.ToTimeT()| returns 100 if
|comparison_time.us_| is 100100000 (usecs) = 100.1 (secs).
So, this condition becomes true if |st_ctime| is 100 (secs) and
|comparison_time.us_| is 100100000 (usecs) = 100.1 (secs).
It may be better to call base::Time::FromTimeT() to convert |st.st_ctime| to
base::Time or call base::Time::ToDoubleT().

[hamaji, 2009/04/22 05:12:23]

Good point. However, if we use Time::DoubleT(), I think there would be another
issue. Please suppose the following case:

1. Get comparison_time by Time::Now() and the value is 100.1 (secs).
2. Create a file and the current time is 100.3 (secs).

As POSIX doesn't have millisecond precision for st_ctime, the creation time of
the file created in the step 2 is 100 and the file is considered older than
|comparison_time|. After all, we may have to accept either of the two issues: 1.
files which are older than |comparison_time| are considered newer (current
implementation) 2. files newer than |comparison_time| are considered older (your
suggestion). I chose the choice 1 just because we have already had sleep before
getting |comparison_time| in file_util_unittest.cc .

[Hironori Bono, 2009/04/22 05:35:58]

I'm wondering why you did not write this comment in your code, which is
definitely useful for convincing readers.

+        ++file_count;
+    }
+    closedir(dir);
+  }
+  return file_count;
+}
+
 // TODO(erikkay): The Windows version of this accepts paths like "foo/bar/*"
 // which works both with and without the recursive flag.  I'm not sure we need
 // that functionality. If not, remove from file_util_win.cc, otherwise add it
 // here.
 bool Delete(const FilePath& path, bool recursive) {
   const char* path_str = path.value().c_str();
   struct stat64 file_info;
   int test = stat64(path_str, &file_info);
   if (test != 0) {
     // The Windows version defines this condition as success.
@@ skipping 520 matching lines @@
     munmap(data_, length_);
   if (file_ != -1)
     close(file_);
 
   data_ = NULL;
   length_ = 0;
   file_ = -1;
 }
 
 } // namespace file_util