Home | History | Annotate | Download | only in common 
      1 // Copyright (c) 2011 The Chromium Authors. All rights reserved.
      2 // Use of this source code is governed by a BSD-style license that can be
      3 // found in the LICENSE file.
      4 
      5 #ifndef CHROME_COMMON_IMPORTANT_FILE_WRITER_H_
      6 #define CHROME_COMMON_IMPORTANT_FILE_WRITER_H_
      7 #pragma once
      8 
      9 #include <string>
     10 
     11 #include "base/basictypes.h"
     12 #include "base/file_path.h"
     13 #include "base/memory/ref_counted.h"
     14 #include "base/threading/non_thread_safe.h"
     15 #include "base/time.h"
     16 #include "base/timer.h"
     17 
     18 namespace base {
     19 class MessageLoopProxy;
     20 class Thread;
     21 }
     22 
     23 // Helper to ensure that a file won't be corrupted by the write (for example on
     24 // application crash). Consider a naive way to save an important file F:
     25 //
     26 // 1. Open F for writing, truncating it.
     27 // 2. Write new data to F.
     28 //
     29 // It's good when it works, but it gets very bad if step 2. doesn't complete.
     30 // It can be caused by a crash, a computer hang, or a weird I/O error. And you
     31 // end up with a broken file.
     32 //
     33 // To be safe, we don't start with writing directly to F. Instead, we write to
     34 // to a temporary file. Only after that write is successful, we rename the
     35 // temporary file to target filename.
     36 //
     37 // If you want to know more about this approach and ext3/ext4 fsync issues, see
     38 // http://valhenson.livejournal.com/37921.html
     39 class ImportantFileWriter : public base::NonThreadSafe {
     40  public:
     41   // Used by ScheduleSave to lazily provide the data to be saved. Allows us
     42   // to also batch data serializations.
     43   class DataSerializer {
     44    public:
     45     virtual ~DataSerializer() {}
     46 
     47     // Should put serialized string in |data| and return true on successful
     48     // serialization. Will be called on the same thread on which
     49     // ImportantFileWriter has been created.
     50     virtual bool SerializeData(std::string* data) = 0;
     51   };
     52 
     53   // Initialize the writer.
     54   // |path| is the name of file to write.
     55   // |file_message_loop_proxy| is the MessageLoopProxy for a thread on which
     56   // file I/O can be done.
     57   // All non-const methods, ctor and dtor must be called on the same thread.
     58   ImportantFileWriter(const FilePath& path,
     59                       base::MessageLoopProxy* file_message_loop_proxy);
     60 
     61   // You have to ensure that there are no pending writes at the moment
     62   // of destruction.
     63   ~ImportantFileWriter();
     64 
     65   const FilePath& path() const { return path_; }
     66 
     67   // Returns true if there is a scheduled write pending which has not yet
     68   // been started.
     69   bool HasPendingWrite() const;
     70 
     71   // Save |data| to target filename. Does not block. If there is a pending write
     72   // scheduled by ScheduleWrite, it is cancelled.
     73   void WriteNow(const std::string& data);
     74 
     75   // Schedule a save to target filename. Data will be serialized and saved
     76   // to disk after the commit interval. If another ScheduleWrite is issued
     77   // before that, only one serialization and write to disk will happen, and
     78   // the most recent |serializer| will be used. This operation does not block.
     79   // |serializer| should remain valid through the lifetime of
     80   // ImportantFileWriter.
     81   void ScheduleWrite(DataSerializer* serializer);
     82 
     83   // Serialize data pending to be saved and execute write on backend thread.
     84   void DoScheduledWrite();
     85 
     86   base::TimeDelta commit_interval() const {
     87     return commit_interval_;
     88   }
     89 
     90   void set_commit_interval(const base::TimeDelta& interval) {
     91     commit_interval_ = interval;
     92   }
     93 
     94  private:
     95   // Path being written to.
     96   const FilePath path_;
     97 
     98   // MessageLoopProxy for the thread on which file I/O can be done.
     99   scoped_refptr<base::MessageLoopProxy> file_message_loop_proxy_;
    100 
    101   // Timer used to schedule commit after ScheduleWrite.
    102   base::OneShotTimer<ImportantFileWriter> timer_;
    103 
    104   // Serializer which will provide the data to be saved.
    105   DataSerializer* serializer_;
    106 
    107   // Time delta after which scheduled data will be written to disk.
    108   base::TimeDelta commit_interval_;
    109 
    110   DISALLOW_COPY_AND_ASSIGN(ImportantFileWriter);
    111 };
    112 
    113 #endif  // CHROME_COMMON_IMPORTANT_FILE_WRITER_H_
    114