[base] fcntl, not fctnl.

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 11 matching lines @@
 namespace base {
 
 // Make sure our Whence mappings match the system headers.
 static_assert(File::FROM_BEGIN == SEEK_SET && File::FROM_CURRENT == SEEK_CUR &&
                   File::FROM_END == SEEK_END,
               "whence mapping must match the system headers");
 
 namespace {
 
 #if defined(OS_BSD) || defined(OS_MACOSX) || defined(OS_NACL)
-static int CallFstat(int fd, stat_wrapper_t *sb) {
+int CallFstat(int fd, stat_wrapper_t *sb) {
   ThreadRestrictions::AssertIOAllowed();
   return fstat(fd, sb);
 }
 #else
-static int CallFstat(int fd, stat_wrapper_t *sb) {
+int CallFstat(int fd, stat_wrapper_t *sb) {
   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) {
+bool IsOpenAppend(PlatformFile file) {
   return (fcntl(file, F_GETFL) & O_APPEND) != 0;
 }
 
-static int CallFtruncate(PlatformFile file, int64 length) {
+int CallFtruncate(PlatformFile file, int64 length) {
   return HANDLE_EINTR(ftruncate(file, length));
 }
 
-static int CallFutimes(PlatformFile file, const struct timeval times[2]) {
+int CallFutimes(PlatformFile file, const struct timeval times[2]) {
 #ifdef __USE_XOPEN2K8
   // futimens should be available, but futimes might not be
   // http://pubs.opengroup.org/onlinepubs/9699919799/
 
   timespec ts_times[2];
   ts_times[0].tv_sec  = times[0].tv_sec;
   ts_times[0].tv_nsec = times[0].tv_usec * 1000;
   ts_times[1].tv_sec  = times[1].tv_sec;
   ts_times[1].tv_nsec = times[1].tv_usec * 1000;
 
   return futimens(file, ts_times);
 #else
   return futimes(file, times);
 #endif
 }
 
-static File::Error CallFctnlFlock(PlatformFile file, bool do_lock) {
+File::Error CallFcntlFlock(PlatformFile file, bool do_lock) {
   struct flock lock;
   lock.l_type = F_WRLCK;
   lock.l_whence = SEEK_SET;
   lock.l_start = 0;
   lock.l_len = 0;  // Lock entire file.
   if (HANDLE_EINTR(fcntl(file, do_lock ? F_SETLK : F_UNLCK, &lock)) == -1)
     return File::OSErrorToFileError(errno);
   return File::FILE_OK;
 }
 #else  // defined(OS_NACL)
 
-static bool IsOpenAppend(PlatformFile file) {
+bool IsOpenAppend(PlatformFile file) {
   // NaCl doesn't implement fcntl. Since NaCl's write conforms to the POSIX
   // standard and always appends if the file is opened with O_APPEND, just
   // return false here.
   return false;
 }
 
-static int CallFtruncate(PlatformFile file, int64 length) {
+int CallFtruncate(PlatformFile file, int64 length) {
   NOTIMPLEMENTED();  // NaCl doesn't implement ftruncate.
   return 0;
 }
 
-static int CallFutimes(PlatformFile file, const struct timeval times[2]) {
+int CallFutimes(PlatformFile file, const struct timeval times[2]) {
   NOTIMPLEMENTED();  // NaCl doesn't implement futimes.
   return 0;
 }
 
-static File::Error CallFctnlFlock(PlatformFile file, bool do_lock) {
+File::Error CallFcntlFlock(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);
@@ skipping 242 matching lines @@
   stat_wrapper_t file_info;
   if (CallFstat(file_.get(), &file_info))
     return false;
 
   info->FromStat(file_info);
   return true;
 }
 
 File::Error File::Lock() {
   SCOPED_FILE_TRACE("Lock");
-  return CallFctnlFlock(file_.get(), true);
+  return CallFcntlFlock(file_.get(), true);
 }
 
 File::Error File::Unlock() {
   SCOPED_FILE_TRACE("Unlock");
-  return CallFctnlFlock(file_.get(), false);
+  return CallFcntlFlock(file_.get(), false);
 }
 
 File File::Duplicate() {
   if (!IsValid())
     return File();
 
   SCOPED_FILE_TRACE("Duplicate");
 
   PlatformFile other_fd = dup(GetPlatformFile());
   if (other_fd == -1)
@@ skipping 143 matching lines @@
   return !HANDLE_EINTR(fsync(file_.get()));
 #endif
 }
 
 void File::SetPlatformFile(PlatformFile file) {
   DCHECK(!file_.is_valid());
   file_.reset(file);
 }
 
 }  // namespace base