Rename SpecificError to OSError to reflect its source

third_party/leveldatabase/env_chromium.cc

 // Copyright (c) 2011 The LevelDB Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file. See the AUTHORS file for names of contributors.
 
 #include <errno.h>
 #include <stdio.h>
 
 #include <deque>
 
 #include "base/at_exit.h"
@@ skipping 162 matching lines @@
       NOTREACHED();
       return "kNumEntries";
   }
   NOTREACHED();
   return "Unknown";
 }
 
 class UMALogger {
  public:
   virtual void RecordErrorAt(MethodID method) const = 0;
-  virtual void RecordSpecificError(MethodID method, int saved_errno) const = 0;
-  virtual void RecordSpecificError(MethodID method,
-                                   base::PlatformFileError error) const = 0;
+  virtual void RecordOSError(MethodID method, int saved_errno) const = 0;
+  virtual void RecordOSError(MethodID method, base::PlatformFileError error)
+      const = 0;
 };
 
 }  // namespace
 
 namespace leveldb {
 
 namespace {
 
 class Thread;
 
@@ skipping 119 matching lines @@
     if (file_ != NULL) {
       // Ignoring any potential errors
       fclose(file_);
     }
   }
 
   virtual Status Append(const Slice& data) {
     size_t r = fwrite_unlocked(data.data(), 1, data.size(), file_);
     Status result;
     if (r != data.size()) {
-      uma_logger_->RecordSpecificError(kWritableFileAppend, errno);
+      uma_logger_->RecordOSError(kWritableFileAppend, errno);
       result = Status::IOError(filename_, strerror(errno));
     }
     return result;
   }
 
   virtual Status Close() {
     Status result;
     if (fclose(file_) != 0) {
       result = Status::IOError(filename_, strerror(errno));
       uma_logger_->RecordErrorAt(kWritableFileClose);
     }
     file_ = NULL;
     return result;
   }
 
   virtual Status Flush() {
     Status result;
     if (HANDLE_EINTR(fflush_unlocked(file_))) {
       int saved_errno = errno;
       result = Status::IOError(filename_, strerror(saved_errno));
-      uma_logger_->RecordSpecificError(kWritableFileFlush, saved_errno);
+      uma_logger_->RecordOSError(kWritableFileFlush, saved_errno);
     }
     return result;
   }
 
   virtual Status Sync() {
     Status result;
     int error = 0;
 
     if (HANDLE_EINTR(fflush_unlocked(file_)))
       error = errno;
@@ skipping 21 matching lines @@
   virtual ~ChromiumEnv() {
     NOTREACHED();
   }
 
   virtual Status NewSequentialFile(const std::string& fname,
                                    SequentialFile** result) {
     FILE* f = fopen_internal(fname.c_str(), "rb");
     if (f == NULL) {
       *result = NULL;
       int saved_errno = errno;
-      RecordSpecificError(kNewSequentialFile, saved_errno);
+      RecordOSError(kNewSequentialFile, saved_errno);
       return Status::IOError(fname, strerror(saved_errno));
     } else {
       *result = new ChromiumSequentialFile(fname, f, this);
       return Status::OK();
     }
   }
 
   virtual Status NewRandomAccessFile(const std::string& fname,
                                      RandomAccessFile** result) {
     int flags = ::base::PLATFORM_FILE_READ | ::base::PLATFORM_FILE_OPEN;
     bool created;
     ::base::PlatformFileError error_code;
     ::base::PlatformFile file = ::base::CreatePlatformFile(
         CreateFilePath(fname), flags, &created, &error_code);
     if (error_code != ::base::PLATFORM_FILE_OK) {
       *result = NULL;
-      RecordSpecificError(kNewRandomAccessFile, error_code);
+      RecordOSError(kNewRandomAccessFile, error_code);
       return Status::IOError(fname, PlatformFileErrorString(error_code));
     }
     *result = new ChromiumRandomAccessFile(fname, file, this);
     return Status::OK();
   }
 
   virtual Status NewWritableFile(const std::string& fname,
                                  WritableFile** result) {
     *result = NULL;
     FILE* f = fopen_internal(fname.c_str(), "wb");
@@ skipping 138 matching lines @@
     ::base::PlatformFileError error_code;
     ::base::PlatformFile file;
     Retrier r(lockfile_time_histogram_, kMaxRenameTimeMillis);
     do {
       file = ::base::CreatePlatformFile(
           CreateFilePath(fname), flags, &created, &error_code);
     } while (error_code != ::base::PLATFORM_FILE_OK && r.ShouldKeepTrying());
 
     if (error_code != ::base::PLATFORM_FILE_OK) {
       result = Status::IOError(fname, PlatformFileErrorString(error_code));
-      RecordSpecificError(kLockFile, error_code);
+      RecordOSError(kLockFile, error_code);
     } else {
       ChromiumFileLock* my_lock = new ChromiumFileLock;
       my_lock->file_ = file;
       *lock = my_lock;
     }
     return result;
   }
 
   virtual Status UnlockFile(FileLock* lock) {
     ChromiumFileLock* my_lock = reinterpret_cast<ChromiumFileLock*>(lock);
@@ skipping 36 matching lines @@
     *path = FilePathToString(test_directory_);
     mu_.Release();
     return Status::OK();
   }
 
   virtual Status NewLogger(const std::string& fname, Logger** result) {
     FILE* f = fopen_internal(fname.c_str(), "w");
     if (f == NULL) {
       *result = NULL;
       int saved_errno = errno;
-      RecordSpecificError(kNewLogger, saved_errno);
+      RecordOSError(kNewLogger, saved_errno);
       return Status::IOError(fname, strerror(saved_errno));
     } else {
       if (!sync_parent(fname)) {
         fclose(f);
         return Status::IOError(fname, strerror(errno));
       }
       *result = new ChromiumLogger(f);
       return Status::OK();
     }
   }
 
   virtual uint64_t NowMicros() {
     return ::base::TimeTicks::Now().ToInternalValue();
   }
 
   virtual void SleepForMicroseconds(int micros) {
     // Round up to the next millisecond.
     ::base::PlatformThread::Sleep(::base::TimeDelta::FromMicroseconds(micros));
   }
 
   void RecordErrorAt(MethodID method) const {
     io_error_histogram_->Add(method);
   }
 
-  void RecordSpecificError(MethodID method, base::PlatformFileError error)
-      const {
+  void RecordOSError(MethodID method, base::PlatformFileError error) const {
     DCHECK(error < 0);
-    RecordSpecificError(method, -error);
+    RecordOSError(method, -error);
   }
 
-  void RecordSpecificError(MethodID method, int error) const {
+  void RecordOSError(MethodID method, int error) const {
     RecordErrorAt(method);
     if (error_histograms_.find(method) == error_histograms_.end()) {
       NOTREACHED();
       return;
     }
     error_histograms_.find(method)->second->Add(error);
   }
 
   void RecordTimeToRename(base::TimeDelta t) const {
     rename_time_histogram_->AddTime(t);
@@ skipping 185 matching lines @@
 
 Env* IDBEnv() {
   return idb_env.Pointer();
 }
 
 Env* Env::Default() {
   return default_env.Pointer();
 }
 
 }