Base: Make file_util and file use the same code to translate from stat to File::Info

base/files/file_posix.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.h"
 
 #include <errno.h>
 #include <fcntl.h>
 #include <sys/stat.h>
 #include <unistd.h>
@@ skipping 14 matching lines @@
 namespace base {
 
 // Make sure our Whence mappings match the system headers.
 COMPILE_ASSERT(File::FROM_BEGIN   == SEEK_SET &&
                File::FROM_CURRENT == SEEK_CUR &&
                File::FROM_END     == SEEK_END, whence_matches_system);
 
 namespace {
 
 #if defined(OS_BSD) || defined(OS_MACOSX) || defined(OS_NACL)
-typedef struct stat stat_wrapper_t;
 static int CallFstat(int fd, stat_wrapper_t *sb) {
   base::ThreadRestrictions::AssertIOAllowed();
   return fstat(fd, sb);
 }
 #else
-typedef struct stat64 stat_wrapper_t;
 static int CallFstat(int fd, stat_wrapper_t *sb) {
   base::ThreadRestrictions::AssertIOAllowed();
   return fstat64(fd, sb);
 }
 #endif
 
 // NaCl doesn't provide the following system calls, so either simulate them or
 // wrap them in order to minimize the number of #ifdef's in this file.
 #if !defined(OS_NACL)
 static bool IsOpenAppend(PlatformFile file) {
@@ skipping 60 matching lines @@
 }
 
 static File::Error CallFctnlFlock(PlatformFile file, bool do_lock) {
   NOTIMPLEMENTED();  // NaCl doesn't implement flock struct.
   return File::FILE_ERROR_INVALID_OPERATION;
 }
 #endif  // defined(OS_NACL)
 
 }  // namespace
 
+void File::Info::FromStat(const stat_wrapper_t& stat_info) {
+  is_directory = S_ISDIR(stat_info.st_mode);
+  is_symbolic_link = S_ISLNK(stat_info.st_mode);
+  size = stat_info.st_size;
+
+#if defined(OS_LINUX)
+  time_t last_modified_sec = stat_info.st_mtim.tv_sec;
+  int64 last_modified_nsec = stat_info.st_mtim.tv_nsec;
+  time_t last_accessed_sec = stat_info.st_atim.tv_sec;
+  int64 last_accessed_nsec = stat_info.st_atim.tv_nsec;
+  time_t creation_time_sec = stat_info.st_ctim.tv_sec;
+  int64 creation_time_nsec = stat_info.st_ctim.tv_nsec;
+#elif defined(OS_ANDROID)
+  time_t last_modified_sec = stat_info.st_mtime;
+  int64 last_modified_nsec = stat_info.st_mtime_nsec;
+  time_t last_accessed_sec = stat_info.st_atime;
+  int64 last_accessed_nsec = stat_info.st_atime_nsec;
+  time_t creation_time_sec = stat_info.st_ctime;
+  int64 creation_time_nsec = stat_info.st_ctime_nsec;
+#elif defined(OS_MACOSX) || defined(OS_IOS) || defined(OS_BSD)
+  time_t last_modified_sec = stat_info.st_mtimespec.tv_sec;
+  int64 last_modified_nsec = stat_info.st_mtimespec.tv_nsec;
+  time_t last_accessed_sec = stat_info.st_atimespec.tv_sec;
+  int64 last_accessed_nsec = stat_info.st_atimespec.tv_nsec;
+  time_t creation_time_sec = stat_info.st_ctimespec.tv_sec;
+  int64 creation_time_nsec = stat_info.st_ctimespec.tv_nsec;
+#else
+  // TODO(gavinp): Investigate a good high resolution option for OS_NACL.

[nfullagar1, 2014/03/28 19:40:15]

couple of nits
-  #else is for default, but comment is specifically for OS_NACL
-  why not use nsec on NaCl?  Not clear to me why setting to 0 would be better. 
(Roland is better than I to answer the details on what resolution NaCl should
return for nsec, but won't be back until Monday)

[rvargas (doing something else), 2014/03/28 19:53:31]

Sure. I was basically just moving this code :)
Even if we have a section for OS_NACL we'd need a default one (looking like
this?). I'm happy to add one if you guys tell me exactly what to do (I'm really
clueless).

[nfullagar1, 2014/03/31 19:59:07]

Talking to Roland NaCl should be zero'ing the nsec fields anyway, so the default
could copy the nsec fields from stat_info as-is instead of resetting them here. 
Suggest also looping in gavinp why nsec fields were zero'd here in the first
place.

On 2014/03/28 19:53:31, rvargas wrote:

[rvargas (doing something else), 2014/03/31 23:02:28]

Given that a default option is needed even if we add an explicit OS_NACL
section, and that this code works as is for NaCl (regardless of overwriting 0
with 0), I'm hesitant to change the behavior for any OS not explicitly covered.

What I'm reading is that there is no need to do anything else for NaCl, so I'm
removing the TODO and leaving the rest of the code as is.

+  time_t last_modified_sec = stat_info.st_mtime;
+  int64 last_modified_nsec = 0;
+  time_t last_accessed_sec = stat_info.st_atime;
+  int64 last_accessed_nsec = 0;
+  time_t creation_time_sec = stat_info.st_ctime;
+  int64 creation_time_nsec = 0;
+#endif
+
+  last_modified =
+      Time::FromTimeT(last_modified_sec) +
+      TimeDelta::FromMicroseconds(last_modified_nsec /
+                                  Time::kNanosecondsPerMicrosecond);
+
+  last_accessed =
+      Time::FromTimeT(last_accessed_sec) +
+      TimeDelta::FromMicroseconds(last_accessed_nsec /
+                                  Time::kNanosecondsPerMicrosecond);
+
+  creation_time =
+      Time::FromTimeT(creation_time_sec) +
+      TimeDelta::FromMicroseconds(creation_time_nsec /
+                                  Time::kNanosecondsPerMicrosecond);
+}
+
 // NaCl doesn't implement system calls to open files directly.
 #if !defined(OS_NACL)
 // TODO(erikkay): does it make sense to support FLAG_EXCLUSIVE_* here?
 void File::InitializeUnsafe(const FilePath& name, uint32 flags) {
   base::ThreadRestrictions::AssertIOAllowed();
   DCHECK(!IsValid());
 
   int open_flags = 0;
   if (flags & FLAG_CREATE)
     open_flags = O_CREAT | O_EXCL;
@@ skipping 245 matching lines @@
   return !CallFutimes(file_.get(), times);
 }
 
 bool File::GetInfo(Info* info) {
   DCHECK(IsValid());
 
   stat_wrapper_t file_info;
   if (CallFstat(file_.get(), &file_info))
     return false;
 
-  info->is_directory = S_ISDIR(file_info.st_mode);
-  info->is_symbolic_link = S_ISLNK(file_info.st_mode);
-  info->size = file_info.st_size;
-
-#if defined(OS_LINUX)
-  const time_t last_modified_sec = file_info.st_mtim.tv_sec;
-  const int64 last_modified_nsec = file_info.st_mtim.tv_nsec;
-  const time_t last_accessed_sec = file_info.st_atim.tv_sec;
-  const int64 last_accessed_nsec = file_info.st_atim.tv_nsec;
-  const time_t creation_time_sec = file_info.st_ctim.tv_sec;
-  const int64 creation_time_nsec = file_info.st_ctim.tv_nsec;
-#elif defined(OS_ANDROID)
-  const time_t last_modified_sec = file_info.st_mtime;
-  const int64 last_modified_nsec = file_info.st_mtime_nsec;
-  const time_t last_accessed_sec = file_info.st_atime;
-  const int64 last_accessed_nsec = file_info.st_atime_nsec;
-  const time_t creation_time_sec = file_info.st_ctime;
-  const int64 creation_time_nsec = file_info.st_ctime_nsec;
-#elif defined(OS_MACOSX) || defined(OS_IOS) || defined(OS_BSD)
-  const time_t last_modified_sec = file_info.st_mtimespec.tv_sec;
-  const int64 last_modified_nsec = file_info.st_mtimespec.tv_nsec;
-  const time_t last_accessed_sec = file_info.st_atimespec.tv_sec;
-  const int64 last_accessed_nsec = file_info.st_atimespec.tv_nsec;
-  const time_t creation_time_sec = file_info.st_ctimespec.tv_sec;
-  const int64 creation_time_nsec = file_info.st_ctimespec.tv_nsec;
-#else
-  // TODO(gavinp): Investigate a good high resolution option for OS_NACL.
-  const time_t last_modified_sec = file_info.st_mtime;
-  const int64 last_modified_nsec = 0;
-  const time_t last_accessed_sec = file_info.st_atime;
-  const int64 last_accessed_nsec = 0;
-  const time_t creation_time_sec = file_info.st_ctime;
-  const int64 creation_time_nsec = 0;
-#endif
-
-  info->last_modified =
-      base::Time::FromTimeT(last_modified_sec) +
-      base::TimeDelta::FromMicroseconds(last_modified_nsec /
-                                        base::Time::kNanosecondsPerMicrosecond);
-  info->last_accessed =
-      base::Time::FromTimeT(last_accessed_sec) +
-      base::TimeDelta::FromMicroseconds(last_accessed_nsec /
-                                        base::Time::kNanosecondsPerMicrosecond);
-  info->creation_time =
-      base::Time::FromTimeT(creation_time_sec) +
-      base::TimeDelta::FromMicroseconds(creation_time_nsec /
-                                        base::Time::kNanosecondsPerMicrosecond);
+  info->FromStat(file_info);
   return true;
 }
 
 File::Error File::Lock() {
   return CallFctnlFlock(file_.get(), true);
 }
 
 File::Error File::Unlock() {
   return CallFctnlFlock(file_.get(), false);
 }
@@ skipping 30 matching lines @@
       return FILE_ERROR_FAILED;
   }
 }
 
 void File::SetPlatformFile(PlatformFile file) {
   DCHECK(!file_.is_valid());
   file_.reset(file);
 }
 
 }  // namespace base