IndexedDB: Cleanup to remove iterators and improve variable names

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 27 matching lines @@
 static base::File::Error LastFileError() {
 #if defined(OS_WIN)
   return base::File::OSErrorToFileError(GetLastError());
 #else
   return base::File::OSErrorToFileError(errno);
 #endif
 }
 
 // Making direct platform in lieu of using base::FileEnumerator because the
 // latter can fail quietly without return an error result.
-static base::File::Error GetDirectoryEntries(
-    const FilePath& dir_param,
-    std::vector<FilePath>* result) {
+static base::File::Error GetDirectoryEntries(const FilePath& dir_param,
+                                             std::vector<FilePath>* result) {
   result->clear();
 #if defined(OS_WIN)
   FilePath dir_filepath = dir_param.Append(FILE_PATH_LITERAL("*"));
   WIN32_FIND_DATA find_data;
   HANDLE find_handle = FindFirstFile(dir_filepath.value().c_str(), &find_data);
   if (find_handle == INVALID_HANDLE_VALUE) {
     DWORD last_error = GetLastError();
     if (last_error == ERROR_FILE_NOT_FOUND)
       return base::File::FILE_OK;
     return base::File::OSErrorToFileError(last_error);
@@ skipping 532 matching lines @@
   bool result = base::CopyFile(base_name.AddExtension(backup_table_extension),
                                table_name);
   std::string uma_name(name_);
   uma_name.append(".TableRestore");
   base::BooleanHistogram::FactoryGet(
       uma_name, base::Histogram::kUmaTargetedHistogramFlag)->AddBoolean(result);
   return table_name;
 }
 
 void ChromiumEnv::RestoreIfNecessary(const std::string& dir,
-                                     std::vector<std::string>* result) {
+                                     std::vector<std::string>* dir_entries) {
   std::set<FilePath> tables_found;
   std::set<FilePath> backups_found;
-  for (std::vector<std::string>::iterator it = result->begin();
-       it != result->end();
-       ++it) {
-    FilePath current = FilePath::FromUTF8Unsafe(*it);
+  for (const auto& entry : *dir_entries) {
+    FilePath current = FilePath::FromUTF8Unsafe(entry);
     if (current.MatchesExtension(table_extension))
       tables_found.insert(current.RemoveExtension());
     if (current.MatchesExtension(backup_table_extension))
       backups_found.insert(current.RemoveExtension());
   }
   std::set<FilePath> backups_only =
       base::STLSetDifference<std::set<FilePath>>(backups_found, tables_found);
 
   if (backups_only.size()) {
     std::string uma_name(name_);
     uma_name.append(".MissingFiles");
     int num_missing_files =
         backups_only.size() > INT_MAX ? INT_MAX : backups_only.size();
     base::Histogram::FactoryGet(uma_name,
                                 1 /*min*/,
                                 100 /*max*/,
                                 8 /*num_buckets*/,
                                 base::Histogram::kUmaTargetedHistogramFlag)
         ->Add(num_missing_files);
   }
-  FilePath dir_filepath = FilePath::FromUTF8Unsafe(dir);
-  for (std::set<FilePath>::iterator it = backups_only.begin();
-       it != backups_only.end(); ++it) {
-    FilePath restored_table_name = RestoreFromBackup(dir_filepath.Append(*it));
-    result->push_back(restored_table_name.BaseName().AsUTF8Unsafe());
+  FilePath dir_path = FilePath::FromUTF8Unsafe(dir);
+  for (const FilePath& backup : backups_only) {

[jsbell, 2014/12/12 18:14:33]

Why FilePath here but auto above (instead of std::string)?

(Just trying to establish a consistent heuristic! I don't have a personal
preference, since I'm so used to `var` in JS...)

+    FilePath restored_table_name = RestoreFromBackup(dir_path.Append(backup));
+    dir_entries->push_back(restored_table_name.BaseName().AsUTF8Unsafe());
   }
 }
 
-Status ChromiumEnv::GetChildren(const std::string& dir_string,
+Status ChromiumEnv::GetChildren(const std::string& dir,
                                 std::vector<std::string>* result) {
   std::vector<FilePath> entries;
   base::File::Error error =
-      GetDirectoryEntries(FilePath::FromUTF8Unsafe(dir_string), &entries);
+      GetDirectoryEntries(FilePath::FromUTF8Unsafe(dir), &entries);
   if (error != base::File::FILE_OK) {
     RecordOSError(kGetChildren, error);
-    return MakeIOError(
-        dir_string, "Could not open/read directory", kGetChildren, error);
+    return MakeIOError(dir, "Could not open/read directory", kGetChildren,
+                       error);
   }
 
   result->clear();
   for (const auto& entry : entries)
     result->push_back(entry.BaseName().AsUTF8Unsafe());
 
   if (make_backup_)
-    RestoreIfNecessary(dir_string, result);
+    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)) {
     result = MakeIOError(fname, "Could not delete file.", kDeleteFile);
@@ skipping 426 matching lines @@
 
 Env* IDBEnv() {
   return leveldb_env::idb_env.Pointer();
 }
 
 Env* Env::Default() {
   return leveldb_env::default_env.Pointer();
 }
 
 }  // namespace leveldb