LevelDB: Removed global prefix from base namespace: "::base" -> "base"

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 "third_party/leveldatabase/env_chromium.h"
 
 #if defined(OS_POSIX)
 #include <dirent.h>
 #include <sys/types.h>
 #endif
@@ skipping 77 matching lines @@
   int saved_errno = errno;
   closedir(dir);
   if (readdir_result != 0)
     return base::File::OSErrorToFileError(saved_errno);
   return base::File::FILE_OK;
 #endif
 }
 
 class ChromiumFileLock : public FileLock {
  public:
-  ::base::File file_;
+  base::File file_;
   std::string name_;
 };
 
 class Retrier {
  public:
   Retrier(MethodID method, RetrierProvider* provider)
       : start_(base::TimeTicks::Now()),
         limit_(start_ + base::TimeDelta::FromMilliseconds(
                             provider->MaxRetryTimeMillis())),
         last_(start_),
@@ skipping 68 matching lines @@
 
  private:
   std::string filename_;
   scoped_ptr<base::File> file_;
   const UMALogger* uma_logger_;
 };
 
 class ChromiumRandomAccessFile : public leveldb::RandomAccessFile {
  public:
   ChromiumRandomAccessFile(const std::string& fname,
-                           ::base::File file,
+                           base::File file,
                            const UMALogger* uma_logger)
       : filename_(fname), file_(file.Pass()), uma_logger_(uma_logger) {}
   virtual ~ChromiumRandomAccessFile() {}
 
   Status Read(uint64_t offset,
               size_t n,
               Slice* result,
               char* scratch) const override {
     Status s;
     int r = file_.Read(offset, scratch, n);
     *result = Slice(scratch, (r < 0) ? 0 : r);
     if (r < 0) {
       // An error: return a non-ok status
       s = MakeIOError(filename_, "Could not perform read",
                       kRandomAccessFileRead);
       uma_logger_->RecordErrorAt(kRandomAccessFileRead);
     }
     return s;
   }
 
  private:
   std::string filename_;
-  mutable ::base::File file_;
+  mutable base::File file_;
   const UMALogger* uma_logger_;
 };
 
 class ChromiumWritableFile : public leveldb::WritableFile {
  public:
   ChromiumWritableFile(const std::string& fname,
                        base::File* f,
                        const UMALogger* uma_logger,
                        WriteTracker* tracker,
                        bool make_backup);
@@ skipping 102 matching lines @@
 }
 
 class IDBEnv : public ChromiumEnv {
  public:
   IDBEnv() : ChromiumEnv() {
     name_ = "LevelDBEnv.IDB";
     make_backup_ = true;
   }
 };
 
-::base::LazyInstance<IDBEnv>::Leaky idb_env = LAZY_INSTANCE_INITIALIZER;
+base::LazyInstance<IDBEnv>::Leaky idb_env = LAZY_INSTANCE_INITIALIZER;
 
-::base::LazyInstance<ChromiumEnv>::Leaky default_env =
-    LAZY_INSTANCE_INITIALIZER;
+base::LazyInstance<ChromiumEnv>::Leaky default_env = LAZY_INSTANCE_INITIALIZER;
 
 }  // unnamed namespace
 
 const char* MethodIDToString(MethodID method) {
   switch (method) {
     case kSequentialFileRead:
       return "SequentialFileRead";
     case kSequentialFileSkip:
       return "SequentialFileSkip";
     case kRandomAccessFileRead:
@@ skipping 187 matching lines @@
       kMaxRetryTimeMillis(1000) {
 }
 
 ChromiumEnv::~ChromiumEnv() {
   // In chromium, ChromiumEnv is leaked. It'd be nice to add NOTREACHED here to
   // ensure that behavior isn't accidentally changed, but there's an instance in
   // a unit test that is deleted.
 }
 
 bool ChromiumEnv::FileExists(const std::string& fname) {
-  return ::base::PathExists(FilePath::FromUTF8Unsafe(fname));
+  return base::PathExists(FilePath::FromUTF8Unsafe(fname));
 }
 
-const char* ChromiumEnv::FileErrorString(::base::File::Error error) {
+const char* ChromiumEnv::FileErrorString(base::File::Error error) {
   switch (error) {
-    case ::base::File::FILE_ERROR_FAILED:
+    case base::File::FILE_ERROR_FAILED:
       return "No further details.";
-    case ::base::File::FILE_ERROR_IN_USE:
+    case base::File::FILE_ERROR_IN_USE:
       return "File currently in use.";
-    case ::base::File::FILE_ERROR_EXISTS:
+    case base::File::FILE_ERROR_EXISTS:
       return "File already exists.";
-    case ::base::File::FILE_ERROR_NOT_FOUND:
+    case base::File::FILE_ERROR_NOT_FOUND:
       return "File not found.";
-    case ::base::File::FILE_ERROR_ACCESS_DENIED:
+    case base::File::FILE_ERROR_ACCESS_DENIED:
       return "Access denied.";
-    case ::base::File::FILE_ERROR_TOO_MANY_OPENED:
+    case base::File::FILE_ERROR_TOO_MANY_OPENED:
       return "Too many files open.";
-    case ::base::File::FILE_ERROR_NO_MEMORY:
+    case base::File::FILE_ERROR_NO_MEMORY:
       return "Out of memory.";
-    case ::base::File::FILE_ERROR_NO_SPACE:
+    case base::File::FILE_ERROR_NO_SPACE:
       return "No space left on drive.";
-    case ::base::File::FILE_ERROR_NOT_A_DIRECTORY:
+    case base::File::FILE_ERROR_NOT_A_DIRECTORY:
       return "Not a directory.";
-    case ::base::File::FILE_ERROR_INVALID_OPERATION:
+    case base::File::FILE_ERROR_INVALID_OPERATION:
       return "Invalid operation.";
-    case ::base::File::FILE_ERROR_SECURITY:
+    case base::File::FILE_ERROR_SECURITY:
       return "Security error.";
-    case ::base::File::FILE_ERROR_ABORT:
+    case base::File::FILE_ERROR_ABORT:
       return "File operation aborted.";
-    case ::base::File::FILE_ERROR_NOT_A_FILE:
+    case base::File::FILE_ERROR_NOT_A_FILE:
       return "The supplied path was not a file.";
-    case ::base::File::FILE_ERROR_NOT_EMPTY:
+    case base::File::FILE_ERROR_NOT_EMPTY:
       return "The file was not empty.";
-    case ::base::File::FILE_ERROR_INVALID_URL:
+    case base::File::FILE_ERROR_INVALID_URL:
       return "Invalid URL.";
-    case ::base::File::FILE_ERROR_IO:
+    case base::File::FILE_ERROR_IO:
       return "OS or hardware error.";
-    case ::base::File::FILE_OK:
+    case base::File::FILE_OK:
       return "OK.";
-    case ::base::File::FILE_ERROR_MAX:
+    case base::File::FILE_ERROR_MAX:
       NOTREACHED();
   }
   NOTIMPLEMENTED();
   return "Unknown error.";
 }
 
 FilePath ChromiumEnv::RestoreFromBackup(const FilePath& base_name) {
   FilePath table_name = base_name.AddExtension(table_extension);
   bool result = base::CopyFile(base_name.AddExtension(backup_table_extension),
                                table_name);
@@ skipping 55 matching lines @@
   if (make_backup_)
     RestoreIfNecessary(dir, result);
 
   return Status::OK();
 }
 
 Status ChromiumEnv::DeleteFile(const std::string& fname) {
   Status result;
   FilePath fname_filepath = FilePath::FromUTF8Unsafe(fname);
   // TODO(jorlow): Should we assert this is a file?
-  if (!::base::DeleteFile(fname_filepath, false)) {
+  if (!base::DeleteFile(fname_filepath, false)) {
     result = MakeIOError(fname, "Could not delete file.", kDeleteFile);
     RecordErrorAt(kDeleteFile);
   }
   if (make_backup_ && fname_filepath.MatchesExtension(table_extension)) {
     base::DeleteFile(fname_filepath.ReplaceExtension(backup_table_extension),
                      false);
   }
   return result;
 }
 
 Status ChromiumEnv::CreateDir(const std::string& name) {
   Status result;
   base::File::Error error = base::File::FILE_OK;
   Retrier retrier(kCreateDir, this);
   do {
     if (base::CreateDirectoryAndGetError(FilePath::FromUTF8Unsafe(name),
                                          &error))
       return result;
   } while (retrier.ShouldKeepTrying(error));
   result = MakeIOError(name, "Could not create directory.", kCreateDir, error);
   RecordOSError(kCreateDir, error);
   return result;
 }
 
 Status ChromiumEnv::DeleteDir(const std::string& name) {
   Status result;
   // TODO(jorlow): Should we assert this is a directory?
-  if (!::base::DeleteFile(FilePath::FromUTF8Unsafe(name), false)) {
+  if (!base::DeleteFile(FilePath::FromUTF8Unsafe(name), false)) {
     result = MakeIOError(name, "Could not delete directory.", kDeleteDir);
     RecordErrorAt(kDeleteDir);
   }
   return result;
 }
 
 Status ChromiumEnv::GetFileSize(const std::string& fname, uint64_t* size) {
   Status s;
   int64_t signed_size;
-  if (!::base::GetFileSize(FilePath::FromUTF8Unsafe(fname), &signed_size)) {
+  if (!base::GetFileSize(FilePath::FromUTF8Unsafe(fname), &signed_size)) {
     *size = 0;
     s = MakeIOError(fname, "Could not determine file size.", kGetFileSize);
     RecordErrorAt(kGetFileSize);
   } else {
     *size = static_cast<uint64_t>(signed_size);
   }
   return s;
 }
 
 Status ChromiumEnv::RenameFile(const std::string& src, const std::string& dst) {
   Status result;
   FilePath src_file_path = FilePath::FromUTF8Unsafe(src);
-  if (!::base::PathExists(src_file_path))
+  if (!base::PathExists(src_file_path))
     return result;
   FilePath destination = FilePath::FromUTF8Unsafe(dst);
 
   Retrier retrier(kRenameFile, this);
   base::File::Error error = base::File::FILE_OK;
   do {
     if (base::ReplaceFile(src_file_path, destination, &error))
       return result;
   } while (retrier.ShouldKeepTrying(error));
 
   DCHECK(error != base::File::FILE_OK);
   RecordOSError(kRenameFile, error);
   char buf[100];
   snprintf(buf,
            sizeof(buf),
            "Could not rename file: %s",
            FileErrorString(error));
   return MakeIOError(src, buf, kRenameFile, error);
 }
 
 Status ChromiumEnv::LockFile(const std::string& fname, FileLock** lock) {
   *lock = NULL;
   Status result;
-  int flags = ::base::File::FLAG_OPEN_ALWAYS |
-              ::base::File::FLAG_READ |
-              ::base::File::FLAG_WRITE;
-  ::base::File::Error error_code;
-  ::base::File file;
+  int flags = base::File::FLAG_OPEN_ALWAYS |
+              base::File::FLAG_READ |
+              base::File::FLAG_WRITE;
+  base::File::Error error_code;
+  base::File file;
   Retrier retrier(kLockFile, this);
   do {
     file.Initialize(FilePath::FromUTF8Unsafe(fname), flags);
     if (!file.IsValid())
       error_code = file.error_details();
   } while (!file.IsValid() && retrier.ShouldKeepTrying(error_code));
 
   if (!file.IsValid()) {
-    if (error_code == ::base::File::FILE_ERROR_NOT_FOUND) {
+    if (error_code == base::File::FILE_ERROR_NOT_FOUND) {
       FilePath parent = FilePath::FromUTF8Unsafe(fname).DirName();
       FilePath last_parent;
       int num_missing_ancestors = 0;
       do {
         if (base::DirectoryExists(parent))
           break;
         ++num_missing_ancestors;
         last_parent = parent;
         parent = parent.DirName();
       } while (parent != last_parent);
       RecordLockFileAncestors(num_missing_ancestors);
     }
 
     result = MakeIOError(fname, FileErrorString(error_code), kLockFile,
                          error_code);
     RecordOSError(kLockFile, error_code);
     return result;
   }
 
   if (!locks_.Insert(fname)) {
     result = MakeIOError(fname, "Lock file already locked.", kLockFile);
     return result;
   }
 
   Retrier lock_retrier = Retrier(kLockFile, this);
   do {
     error_code = file.Lock();
-  } while (error_code != ::base::File::FILE_OK &&
+  } while (error_code != base::File::FILE_OK &&
            retrier.ShouldKeepTrying(error_code));
 
-  if (error_code != ::base::File::FILE_OK) {
+  if (error_code != base::File::FILE_OK) {
     locks_.Remove(fname);
     result = MakeIOError(fname, FileErrorString(error_code), kLockFile,
                          error_code);
     RecordOSError(kLockFile, error_code);
     return result;
   }
 
   ChromiumFileLock* my_lock = new ChromiumFileLock;
   my_lock->file_ = file.Pass();
   my_lock->name_ = fname;
   *lock = my_lock;
   return result;
 }
 
 Status ChromiumEnv::UnlockFile(FileLock* lock) {
   ChromiumFileLock* my_lock = reinterpret_cast<ChromiumFileLock*>(lock);
   Status result;
 
-  ::base::File::Error error_code = my_lock->file_.Unlock();
-  if (error_code != ::base::File::FILE_OK) {
+  base::File::Error error_code = my_lock->file_.Unlock();
+  if (error_code != base::File::FILE_OK) {
     result =
         MakeIOError(my_lock->name_, "Could not unlock lock file.", kUnlockFile);
     RecordOSError(kUnlockFile, error_code);
   }
   bool removed = locks_.Remove(my_lock->name_);
   DCHECK(removed);
   delete my_lock;
   return result;
 }
 
@@ skipping 50 matching lines @@
   GetMaxFDHistogram(type)->Add(base::GetMaxFds());
 #elif defined(OS_WIN)
 // Windows is only limited by available memory
 #else
 #error "Need to determine limit to open files for this OS"
 #endif
 }
 
 Status ChromiumEnv::NewRandomAccessFile(const std::string& fname,
                                         leveldb::RandomAccessFile** result) {
-  int flags = ::base::File::FLAG_READ | ::base::File::FLAG_OPEN;
-  ::base::File file(FilePath::FromUTF8Unsafe(fname), flags);
+  int flags = base::File::FLAG_READ | base::File::FLAG_OPEN;
+  base::File file(FilePath::FromUTF8Unsafe(fname), flags);
   if (file.IsValid()) {
     *result = new ChromiumRandomAccessFile(fname, file.Pass(), this);
     RecordOpenFilesLimit("Success");
     return Status::OK();
   }
-  ::base::File::Error error_code = file.error_details();
-  if (error_code == ::base::File::FILE_ERROR_TOO_MANY_OPENED)
+  base::File::Error error_code = file.error_details();
+  if (error_code == base::File::FILE_ERROR_TOO_MANY_OPENED)
     RecordOpenFilesLimit("TooManyOpened");
   else
     RecordOpenFilesLimit("OtherError");
   *result = NULL;
   RecordOSError(kNewRandomAccessFile, error_code);
   return MakeIOError(fname, FileErrorString(error_code), kNewRandomAccessFile,
                      error_code);
 }
 
 Status ChromiumEnv::NewWritableFile(const std::string& fname,
                                     leveldb::WritableFile** result) {
   *result = NULL;
   FilePath path = FilePath::FromUTF8Unsafe(fname);
   scoped_ptr<base::File> f(new base::File(
       path, base::File::FLAG_CREATE_ALWAYS | base::File::FLAG_WRITE));
   if (!f->IsValid()) {
     RecordErrorAt(kNewWritableFile);
     return MakeIOError(fname, "Unable to create writable file",
                        kNewWritableFile, f->error_details());
   } else {
     *result =
         new ChromiumWritableFile(fname, f.release(), this, this, make_backup_);
     return Status::OK();
   }
 }
 
 uint64_t ChromiumEnv::NowMicros() {
-  return ::base::TimeTicks::Now().ToInternalValue();
+  return base::TimeTicks::Now().ToInternalValue();
 }
 
 void ChromiumEnv::SleepForMicroseconds(int micros) {
   // Round up to the next millisecond.
-  ::base::PlatformThread::Sleep(::base::TimeDelta::FromMicroseconds(micros));
+  base::PlatformThread::Sleep(base::TimeDelta::FromMicroseconds(micros));
 }
 
 void ChromiumEnv::RecordErrorAt(MethodID method) const {
   GetMethodIOErrorHistogram()->Add(method);
 }
 
 void ChromiumEnv::RecordLockFileAncestors(int num_missing_ancestors) const {
   GetLockFileAncestorHistogram()->Add(num_missing_ancestors);
 }
 
@@ skipping 68 matching lines @@
 
 base::HistogramBase* ChromiumEnv::GetRecoveredFromErrorHistogram(
     MethodID method) const {
   std::string uma_name(name_);
   uma_name.append(".RetryRecoveredFromErrorIn")
       .append(MethodIDToString(method));
   return base::LinearHistogram::FactoryGet(uma_name, 1, kNumEntries,
       kNumEntries + 1, base::Histogram::kUmaTargetedHistogramFlag);
 }
 
-class Thread : public ::base::PlatformThread::Delegate {
+class Thread : public base::PlatformThread::Delegate {
  public:
   Thread(void (*function)(void* arg), void* arg)
       : function_(function), arg_(arg) {
-    ::base::PlatformThreadHandle handle;
-    bool success = ::base::PlatformThread::Create(0, this, &handle);
+    base::PlatformThreadHandle handle;
+    bool success = base::PlatformThread::Create(0, this, &handle);
     DCHECK(success);
   }
   virtual ~Thread() {}
   void ThreadMain() override {
     (*function_)(arg_);
     delete this;
   }
 
  private:
   void (*function_)(void* arg);
@@ skipping 72 matching lines @@
 
 Env* IDBEnv() {
   return leveldb_env::idb_env.Pointer();
 }
 
 Env* Env::Default() {
   return leveldb_env::default_env.Pointer();
 }
 
 }  // namespace leveldb