Moved JsonPrefStore to use SequencedWorkerPool

chrome/browser/extensions/test_extension_prefs.cc

 // Copyright (c) 2012 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/browser/extensions/test_extension_prefs.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/file_util.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop.h"
 #include "base/message_loop_proxy.h"
 #include "base/synchronization/waitable_event.h"
+#include "base/threading/sequenced_worker_pool.h"
 #include "base/values.h"
 #include "chrome/browser/extensions/extension_pref_store.h"
 #include "chrome/browser/extensions/extension_pref_value_map.h"
 #include "chrome/browser/extensions/extension_prefs.h"
 #include "chrome/browser/prefs/pref_service.h"
 #include "chrome/browser/prefs/pref_service_mock_builder.h"
 #include "chrome/browser/prefs/pref_value_store.h"
 #include "chrome/common/extensions/extension.h"
 #include "chrome/common/extensions/extension_manifest_constants.h"
 #include "chrome/common/json_pref_store.h"
@@ skipping 23 matching lines @@
   mutable base::Time currentTime;
 
   virtual base::Time GetCurrentTime() const {
     currentTime += base::TimeDelta::FromSeconds(10);
     return currentTime;
   }
 };
 
 }  // namespace
 
-TestExtensionPrefs::TestExtensionPrefs()
-    : pref_service_(NULL),
-      extensions_disabled_(false) {
+TestExtensionPrefs::TestExtensionPrefs(
+    base::SequencedWorkerPool* blocking_pool) : pref_service_(NULL),
+                                                extensions_disabled_(false) {
+  blocking_pool_ = blocking_pool;
   EXPECT_TRUE(temp_dir_.CreateUniqueTempDir());
   preferences_file_ = temp_dir_.path().AppendASCII("Preferences");
   extensions_dir_ = temp_dir_.path().AppendASCII("Extensions");
   EXPECT_TRUE(file_util::CreateDirectory(extensions_dir_));
 
   RecreateExtensionPrefs();
 }
 
-TestExtensionPrefs::~TestExtensionPrefs() {}
+TestExtensionPrefs::~TestExtensionPrefs() {
+}
 
 void TestExtensionPrefs::RecreateExtensionPrefs() {
   // We persist and reload the PrefService's PrefStores because this process
   // deletes all empty dictionaries. The ExtensionPrefs implementation
   // needs to be able to handle this situation.
   if (pref_service_.get()) {
-    // The PrefService writes its persistent file on the file thread, so we
-    // need to wait for any pending I/O to complete before creating a new
-    // PrefService.
-    base::WaitableEvent io_finished(false, false);
-    pref_service_-> CommitPendingWrite();
-    EXPECT_TRUE(BrowserThread::PostTask(
-        BrowserThread::FILE,
-        FROM_HERE,
-        base::Bind(&base::WaitableEvent::Signal,
-                   base::Unretained(&io_finished))));
-
-    // If the FILE thread is in fact the current thread (possible in testing
-    // scenarios), we have to ensure the task has a chance to run. If the FILE
-    // thread is a different thread, the test must ensure that thread is running
-    // (otherwise the Wait below will hang).
-    MessageLoop::current()->RunAllPending();
-
-    io_finished.Wait();
+    pref_service_->CommitPendingWrite();
+    blocking_pool_->FlushForTesting();

[akalin, 2012/10/18 23:52:24]

i think you can replace the FlushForTesting call with:

void DoNothing() {}

    base::RunLoop run_loop;
    ASSERT_TRUE(
        task_runner_->PostTaskAndReply(
            FROM_HERE,
            base::Bind(&DoNothing),
            run_loop.QuitClosure()));
    run_loop.Run();

If CommitPendingWrite() just posts a task to the task_runner_, that should
suffice.

[zel, 2012/10/19 01:20:32]

Done.

   }
 
   extension_pref_value_map_.reset(new ExtensionPrefValueMap);
   PrefServiceMockBuilder builder;
-  builder.WithUserFilePrefs(preferences_file_);
+  builder.WithUserFilePrefs(preferences_file_, blocking_pool_.get());
   builder.WithExtensionPrefs(
       new ExtensionPrefStore(extension_pref_value_map_.get(), false));
   pref_service_.reset(builder.Create());
   ExtensionPrefs::RegisterUserPrefs(pref_service_.get());
 
   prefs_.reset(new MockExtensionPrefs(pref_service_.get(),
                                       temp_dir_.path(),
                                       extension_pref_value_map_.get()));
   prefs_->Init(extensions_disabled_);
 }
@@ skipping 50 matching lines @@
 PrefService* TestExtensionPrefs::CreateIncognitoPrefService() const {
   return pref_service_->CreateIncognitoPrefService(
       new ExtensionPrefStore(extension_pref_value_map_.get(), true));
 }
 
 void TestExtensionPrefs::set_extensions_disabled(bool extensions_disabled) {
   extensions_disabled_ = extensions_disabled;
 }
 
 }  // namespace extensions