Tweak commit interval for ScheduleSavePersistentPrefs.

chrome/common/important_file_writer.cc

-// Copyright (c) 2010 The Chromium Authors. All rights reserved.
+// Copyright (c) 2011 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "chrome/common/important_file_writer.h"
 
 #include <stdio.h>
 
 #include <string>
 
 #include "base/file_path.h"
 #include "base/file_util.h"
 #include "base/logging.h"
 #include "base/message_loop_proxy.h"
+#include "base/rand_util.h"
 #include "base/string_number_conversions.h"
 #include "base/task.h"
 #include "base/threading/thread.h"
 #include "base/time.h"
 
-using base::TimeDelta;
-
 namespace {
 
-const int kDefaultCommitIntervalMs = 10000;
+base::TimeDelta EstimateDesiredCommitInterval() {
+  // 2 seconds interval provides reasonable optimization by coalescing bursts of
+  // writes yet this value is reasonably low to be safe.
+  const int kSafeCommitIntervalMs = 2000;
+
+  static int commit_interval = 0;
+  if (commit_interval == 0) {
+    commit_interval = kSafeCommitIntervalMs;
+
+#if !defined(OFFICIAL_BUILD) && !defined(GOOGLE_CHROME_BUILD)
+    // For debugging purpose we may want to increase commit interval in order to
+    // ease manifestation of bugs caused by some exit path failing to commit
+    // pending writes (as in http://crosbug.com/13102).
+    const int kDebugCommitIntervalMs = 60000;
+
+    // Leave 50% chance to match behaviour of official build.
+    if (base::RandInt(0, 1))

[Paweł Hajdan Jr., 2011/03/21 13:27:43]

I'm strongly against any randomness in this code. We have tools to detect
problems, and randomness in the code itself just makes reproducing problems more
complicated. Ditto about the #defines in the area.

On the other hand, decreasing the commit interval to 2s is fine for me.

+      commit_interval = kDebugCommitIntervalMs;
+#endif
+  }
+  return base::TimeDelta::FromMilliseconds(commit_interval);
+}
 
 class WriteToDiskTask : public Task {
  public:
   WriteToDiskTask(const FilePath& path, const std::string& data)
       : path_(path),
         data_(data) {
   }
 
   virtual void Run() {
     // Write the data to a temp file then rename to avoid data loss if we crash
@@ skipping 40 matching lines @@
   DISALLOW_COPY_AND_ASSIGN(WriteToDiskTask);
 };
 
 }  // namespace
 
 ImportantFileWriter::ImportantFileWriter(
     const FilePath& path, base::MessageLoopProxy* file_message_loop_proxy)
         : path_(path),
           file_message_loop_proxy_(file_message_loop_proxy),
           serializer_(NULL),
-          commit_interval_(TimeDelta::FromMilliseconds(
-              kDefaultCommitIntervalMs)) {
+          commit_interval_(EstimateDesiredCommitInterval()) {
   DCHECK(CalledOnValidThread());
   DCHECK(file_message_loop_proxy_.get());
 }
 
 ImportantFileWriter::~ImportantFileWriter() {
   // We're usually a member variable of some other object, which also tends
   // to be our serializer. It may not be safe to call back to the parent object
   // being destructed.
   DCHECK(!HasPendingWrite());
 }
@@ skipping 43 matching lines @@
   DCHECK(serializer_);
   std::string data;
   if (serializer_->SerializeData(&data)) {
     WriteNow(data);
   } else {
     LOG(WARNING) << "failed to serialize data to be saved in "
                  << path_.value();
   }
   serializer_ = NULL;
 }