leveldb: Env no longer implicitly syncs dir for all newly created files.

third_party/leveldatabase/env_chromium.h

 // Copyright (c) 2013 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.
 
 #ifndef THIRD_PARTY_LEVELDATABASE_ENV_CHROMIUM_H_
 #define THIRD_PARTY_LEVELDATABASE_ENV_CHROMIUM_H_
 
 #include <deque>
 #include <set>
 #include <string>
@@ skipping 69 matching lines @@
 };
 
 class RetrierProvider {
  public:
   virtual int MaxRetryTimeMillis() const = 0;
   virtual base::HistogramBase* GetRetryTimeHistogram(MethodID method) const = 0;
   virtual base::HistogramBase* GetRecoveredFromErrorHistogram(
       MethodID method) const = 0;
 };
 
-class WriteTracker {
- public:
-  virtual void DidCreateNewFile(const std::string& fname) = 0;
-  virtual bool DoesDirNeedSync(const std::string& fname) = 0;
-  virtual void DidSyncDir(const std::string& fname) = 0;
-};
-
 class ChromiumEnv : public leveldb::Env,
                     public UMALogger,
-                    public RetrierProvider,
-                    public WriteTracker {
+                    public RetrierProvider {
  public:
   ChromiumEnv();
 
   typedef void(ScheduleFunc)(void*);
 
   static bool MakeBackup(const std::string& fname);
   virtual ~ChromiumEnv();
 
   virtual bool FileExists(const std::string& fname);
   virtual leveldb::Status GetChildren(const std::string& dir,
@@ skipping 18 matching lines @@
       const std::string& fname,
       leveldb::RandomAccessFile** result);
   virtual leveldb::Status NewWritableFile(const std::string& fname,
                                           leveldb::WritableFile** result);
   virtual leveldb::Status NewAppendableFile(const std::string& fname,
                                             leveldb::WritableFile** result);
   virtual leveldb::Status NewLogger(const std::string& fname,
                                     leveldb::Logger** result);
 
  protected:
-  virtual void DidSyncDir(const std::string& fname);
-
   std::string name_;
   bool make_backup_;
 
  private:
   static const char* FileErrorString(base::File::Error error);
 
-  virtual void DidCreateNewFile(const std::string& fname);
-  virtual bool DoesDirNeedSync(const std::string& fname);
   virtual void RecordErrorAt(MethodID method) const;
   virtual void RecordOSError(MethodID method,
                              base::File::Error error) const;
   void RecordOpenFilesLimit(const std::string& type);
   base::HistogramBase* GetMaxFDHistogram(const std::string& type) const;
   base::HistogramBase* GetOSErrorHistogram(MethodID method, int limit) const;
 
   // File locks may not be exclusive within a process (e.g. on POSIX). Track
   // locks held by the ChromiumEnv to prevent access within the process.
   class LockTable {
    public:
     bool Insert(const std::string& fname) {
       leveldb::MutexLock l(&mu_);
       return locked_files_.insert(fname).second;
     }
     bool Remove(const std::string& fname) {
       leveldb::MutexLock l(&mu_);
       return locked_files_.erase(fname) == 1;
     }
    private:
     leveldb::port::Mutex mu_;
     std::set<std::string> locked_files_;
   };
 
-  std::set<std::string> directories_needing_sync_;
-  base::Lock directory_sync_lock_;
-
   const int kMaxRetryTimeMillis;
   // BGThread() is the body of the background thread
   void BGThread();
   static void BGThreadWrapper(void* arg) {
     reinterpret_cast<ChromiumEnv*>(arg)->BGThread();
   }
 
   virtual void RecordBackupResult(bool result) const;
   void RestoreIfNecessary(const std::string& dir,
                           std::vector<std::string>* children);
@@ skipping 20 matching lines @@
     void (*function)(void*);
   };
   typedef std::deque<BGItem> BGQueue;
   BGQueue queue_;
   LockTable locks_;
 };
 
 }  // namespace leveldb_env
 
 #endif  // THIRD_PARTY_LEVELDATABASE_ENV_CHROMIUM_H_