Use file_util::GetFileSystemType() in crypto/nss_util.cc.

crypto/nss_util.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 "crypto/nss_util.h"
 #include "crypto/nss_util_internal.h"
 
 #include <nss.h>
 #include <pk11pub.h>
 #include <plarena.h>
 #include <prerror.h>
 #include <prinit.h>
 #include <prtime.h>
 #include <secmod.h>
 
-#if defined(OS_LINUX)
-#include <linux/nfs_fs.h>
-#include <sys/vfs.h>
-#elif defined(OS_OPENBSD)
+#if defined(OS_OPENBSD)
 #include <sys/mount.h>
 #include <sys/param.h>
 #endif
 
 #include <map>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/cpu.h"
@@ skipping 110 matching lines @@
 // the NSS environment variable NSS_SDB_USE_CACHE to "yes" to override NSS's
 // detection when database_dir is on NFS.  See http://crbug.com/48585.
 //
 // TODO(wtc): port this function to other USE_NSS platforms.  It is defined
 // only for OS_LINUX and OS_OPENBSD simply because the statfs structure
 // is OS-specific.
 //
 // Because this function sets an environment variable it must be run before we
 // go multi-threaded.
 void UseLocalCacheOfNSSDatabaseIfNFS(const base::FilePath& database_dir) {
-#if defined(OS_LINUX) || defined(OS_OPENBSD)
+  bool db_on_nfs = false;
+#if defined(OS_LINUX)
+  file_util::FileSystemType fs_type = file_util::FILE_SYSTEM_UNKNOWN;
+  if (file_util::GetFileSystemType(database_dir, &fs_type))
+    db_on_nfs = (fs_type == file_util::FILE_SYSTEM_NFS);
+#elif defined(OS_OPENBSD)
   struct statfs buf;
-  if (statfs(database_dir.value().c_str(), &buf) == 0) {
-#if defined(OS_LINUX)
-    if (buf.f_type == NFS_SUPER_MAGIC) {
-#elif defined(OS_OPENBSD)
-    if (strcmp(buf.f_fstypename, MOUNT_NFS) == 0) {
+  if (statfs(database_dir.value().c_str(), &buf) == 0)
+    db_on_nfs = (strcmp(buf.f_fstypename, MOUNT_NFS) == 0);
+#else
+  NOTIMPLEMENTED();
 #endif
-      scoped_ptr<base::Environment> env(base::Environment::Create());
-      const char* use_cache_env_var = "NSS_SDB_USE_CACHE";
-      if (!env->HasVar(use_cache_env_var))
-        env->SetVar(use_cache_env_var, "yes");
-    }
+
+  if (db_on_nfs) {
+    scoped_ptr<base::Environment> env(base::Environment::Create());
+    static const char kUseCacheEnvVar[] = "NSS_SDB_USE_CACHE";
+    if (!env->HasVar(kUseCacheEnvVar))
+      env->SetVar(kUseCacheEnvVar, "yes");
   }
-#endif  // defined(OS_LINUX) || defined(OS_OPENBSD)
 }
 
 #endif  // defined(USE_NSS)
 
 // A singleton to initialize/deinitialize NSPR.
 // Separate from the NSS singleton because we initialize NSPR on the UI thread.
 // Now that we're leaking the singleton, we could merge back with the NSS
 // singleton.
 class NSPRInitSingleton {
  private:
@@ skipping 727 matching lines @@
   // Ubuntu 11.10 (Oneiric) and Debian Wheezy place the libraries here.
 #if defined(ARCH_CPU_X86_64)
   paths.push_back(base::FilePath("/usr/lib/x86_64-linux-gnu/nss"));
 #elif defined(ARCH_CPU_X86)
   paths.push_back(base::FilePath("/usr/lib/i386-linux-gnu/nss"));
 #elif defined(ARCH_CPU_ARMEL)
 #if defined(__ARM_PCS_VFP)
   paths.push_back(base::FilePath("/usr/lib/arm-linux-gnueabihf/nss"));
 #else
   paths.push_back(base::FilePath("/usr/lib/arm-linux-gnueabi/nss"));
-#endif
+#endif  // defined(__ARM_PCS_VFP)
 #elif defined(ARCH_CPU_MIPSEL)
   paths.push_back(base::FilePath("/usr/lib/mipsel-linux-gnu/nss"));
-#endif
+#endif  // defined(ARCH_CPU_X86_64)
 
   // A list of library files to load.
   std::vector<std::string> libs;
   libs.push_back("libsoftokn3.so");
   libs.push_back("libfreebl3.so");
 
   // For each combination of library file and path, check for existence and
   // then load.
   size_t loaded = 0;
   for (size_t i = 0; i < libs.size(); ++i) {
     for (size_t j = 0; j < paths.size(); ++j) {
       base::FilePath path = paths[j].Append(libs[i]);
       base::NativeLibrary lib = base::LoadNativeLibrary(path, NULL);
       if (lib) {
         ++loaded;
         break;
       }
     }
   }
 
   if (loaded == libs.size()) {
     VLOG(3) << "NSS libraries loaded.";
   } else {
     LOG(ERROR) << "Failed to load NSS libraries.";
   }
-#endif
+#endif  // defined(USE_NSS)
 }
 
 bool CheckNSSVersion(const char* version) {
   return !!NSS_VersionCheck(version);
 }
 
 #if defined(USE_NSS)
 ScopedTestNSSDB::ScopedTestNSSDB()
   : is_open_(g_nss_singleton.Get().OpenTestNSSDB()) {
 }
@@ skipping 117 matching lines @@
 
 PK11SlotInfo* GetPublicNSSKeySlot() {
   return g_nss_singleton.Get().GetPublicNSSKeySlot();
 }
 
 PK11SlotInfo* GetPrivateNSSKeySlot() {
   return g_nss_singleton.Get().GetPrivateNSSKeySlot();
 }
 
 }  // namespace crypto