Cleanup Chrome's LevelDB env to conform to C++ style guidelines.

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_WIN)
+#include <io.h>
+#endif
+
 #include "base/debug/trace_event.h"
 #include "base/file_util.h"
 #include "base/lazy_instance.h"
 #include "base/metrics/histogram.h"
 #include "base/strings/utf_string_conversions.h"
-#include "env_chromium_stdio.h"
+#include "third_party/leveldatabase/env_chromium_stdio.h"
 #include "third_party/re2/re2/re2.h"
 
 #if defined(OS_WIN)
-#include <io.h>
 #include "base/command_line.h"
 #include "base/win/win_util.h"
-#include "env_chromium_win.h"
+#include "third_parth/leveldatabase/env_chromium_win.h"

[jsbell, 2014/07/23 19:09:09]

typo: third_part**h**

 #endif
 
-using namespace leveldb;
+using leveldb::FileLock;
+using leveldb::Slice;
+using leveldb::Status;
 
 namespace leveldb_env {
 
 namespace {
 
 const base::FilePath::CharType backup_table_extension[] =
     FILE_PATH_LITERAL(".bak");
 const base::FilePath::CharType table_extension[] = FILE_PATH_LITERAL(".ldb");
 
 static const base::FilePath::CharType kLevelDBTestDirectoryPrefix[]
@@ skipping 14 matching lines @@
         last_(start_),
         time_to_sleep_(base::TimeDelta::FromMilliseconds(10)),
         success_(true),
         method_(method),
         last_error_(base::File::FILE_OK),
         provider_(provider) {}
   ~Retrier() {
     if (success_) {
       provider_->GetRetryTimeHistogram(method_)->AddTime(last_ - start_);
       if (last_error_ != base::File::FILE_OK) {
-        DCHECK(last_error_ < 0);
+        DCHECK_LT(last_error_, 0);
         provider_->GetRecoveredFromErrorHistogram(method_)->Add(-last_error_);
       }
     }
   }
   bool ShouldKeepTrying(base::File::Error last_error) {
     DCHECK_NE(last_error, base::File::FILE_OK);
     last_error_ = last_error;
     if (last_ < limit_) {
       base::PlatformThread::Sleep(time_to_sleep_);
       last_ = base::TimeTicks::Now();
@@ skipping 109 matching lines @@
            method,
            MethodIDToString(method),
            saved_errno);
   return Status::IOError(filename, buf);
 }
 
 Status MakeIOError(Slice filename,
                    const char* message,
                    MethodID method,
                    base::File::Error error) {
-  DCHECK(error < 0);
+  DCHECK_LT(error, 0);
   char buf[512];
   snprintf(buf,
            sizeof(buf),
            "%s (ChromeMethodPFE: %d::%s::%d)",
            message,
            method,
            MethodIDToString(method),
            -error);
   return Status::IOError(filename, buf);
 }
@@ skipping 141 matching lines @@
 #endif
 }
 
 bool ChromiumEnv::MakeBackup(const std::string& fname) {
   base::FilePath original_table_name = CreateFilePath(fname);
   base::FilePath backup_table_name =
       original_table_name.ReplaceExtension(backup_table_extension);
   return base::CopyFile(original_table_name, backup_table_name);
 }
 
-bool ChromiumEnv::HasTableExtension(const base::FilePath& path)
-{
+bool ChromiumEnv::HasTableExtension(const base::FilePath& path) {
   return path.MatchesExtension(table_extension);
 }
 
 ChromiumEnv::ChromiumEnv()
     : name_("LevelDBEnv"),
       make_backup_(false),
       bgsignal_(&mu_),
       started_bgthread_(false),
       kMaxRetryTimeMillis(1000) {
 }
@@ skipping 307 matching lines @@
 void ChromiumEnv::RecordErrorAt(MethodID method) const {
   GetMethodIOErrorHistogram()->Add(method);
 }
 
 void ChromiumEnv::RecordLockFileAncestors(int num_missing_ancestors) const {
   GetLockFileAncestorHistogram()->Add(num_missing_ancestors);
 }
 
 void ChromiumEnv::RecordOSError(MethodID method,
                                 base::File::Error error) const {
-  DCHECK(error < 0);
+  DCHECK_LT(error, 0);
   RecordErrorAt(method);
   GetOSErrorHistogram(method, -base::File::FILE_ERROR_MAX)->Add(-error);
 }
 
 void ChromiumEnv::RecordOSError(MethodID method, int error) const {
-  DCHECK(error > 0);
+  DCHECK_GT(error, 0);
   RecordErrorAt(method);
   GetOSErrorHistogram(method, ERANGE + 1)->Add(error);
 }
 
 void ChromiumEnv::RecordBackupResult(bool result) const {
   std::string uma_name(name_);
   uma_name.append(".TableBackup");
   base::BooleanHistogram::FactoryGet(
       uma_name, base::Histogram::kUmaTargetedHistogramFlag)->AddBoolean(result);
 }
@@ skipping 74 matching lines @@
   virtual void ThreadMain() {
     (*function_)(arg_);
     delete this;
   }
 
  private:
   void (*function_)(void* arg);
   void* arg_;
 };
 
-void ChromiumEnv::Schedule(void (*function)(void*), void* arg) {
+void ChromiumEnv::Schedule(ScheduleFunc* function, void* arg) {
   mu_.Acquire();
 
   // Start background thread if necessary
   if (!started_bgthread_) {
     started_bgthread_ = true;
     StartThread(&ChromiumEnv::BGThreadWrapper, this);
   }
 
   // If the queue is currently empty, the background thread may currently be
   // waiting.
@@ skipping 23 matching lines @@
     void* arg = queue_.front().arg;
     queue_.pop_front();
 
     mu_.Release();
     TRACE_EVENT0("leveldb", "ChromiumEnv::BGThread-Task");
     (*function)(arg);
   }
 }
 
 void ChromiumEnv::StartThread(void (*function)(void* arg), void* arg) {
-  new Thread(function, arg); // Will self-delete.
+  new Thread(function, arg);  // Will self-delete.
 }
 
 static std::string GetDirName(const std::string& filename) {
   base::FilePath file = base::FilePath::FromUTF8Unsafe(filename);
   return FilePathToString(file.DirName());
 }
 
 void ChromiumEnv::DidCreateNewFile(const std::string& filename) {
   base::AutoLock auto_lock(map_lock_);
   needs_sync_map_[GetDirName(filename)] = true;
@@ skipping 16 matching lines @@
 Env* IDBEnv() {
   return leveldb_env::idb_env.Pointer();
 }
 
 Env* Env::Default() {
   return leveldb_env::default_env.Pointer();
 }
 
 }  // namespace leveldb