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: ~DataSerializer()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 path()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 commit_interval()86 base::TimeDelta commit_interval() const { 87 return commit_interval_; 88 } 89 set_commit_interval(const base::TimeDelta & interval)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