Revert 269415 "Introduce a new framework for back-and-forth trac..."

trunk/src/chrome/browser/prefs/tracked/segregated_pref_store_unittest.cc

 // Copyright 2014 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/prefs/tracked/segregated_pref_store.h"
 
 #include <set>
 #include <string>
 
 #include "base/bind.h"
@@ skipping 39 matching lines @@
 
  private:
   Data* data_;
 };
 
 }  // namespace
 
 class SegregatedPrefStoreTest : public testing::Test {
  public:
   SegregatedPrefStoreTest()
-      : read_error_delegate_data_(false,
+      : initialization_callback_invoked_(false),
+        read_error_delegate_data_(false,
                                   PersistentPrefStore::PREF_READ_ERROR_NONE),
         read_error_delegate_(
             new MockReadErrorDelegate(&read_error_delegate_data_)) {}
 
   virtual void SetUp() OVERRIDE {
     selected_store_ = new TestingPrefStore;
     default_store_ = new TestingPrefStore;
 
     std::set<std::string> selected_pref_names;
     selected_pref_names.insert(kSelectedPref);
 
     segregated_store_ = new SegregatedPrefStore(
         default_store_,
         selected_store_,
-        selected_pref_names);
+        selected_pref_names,
+        base::Bind(&SegregatedPrefStoreTest::InitializationCallback,
+                   base::Unretained(this)));
 
     segregated_store_->AddObserver(&observer_);
   }
 
   virtual void TearDown() OVERRIDE {
     segregated_store_->RemoveObserver(&observer_);
   }
 
  protected:
   scoped_ptr<PersistentPrefStore::ReadErrorDelegate> GetReadErrorDelegate() {
     EXPECT_TRUE(read_error_delegate_);
     return read_error_delegate_
         .PassAs<PersistentPrefStore::ReadErrorDelegate>();
   }
 
   PrefStoreObserverMock observer_;
+  bool initialization_callback_invoked_;
 
   scoped_refptr<TestingPrefStore> default_store_;
   scoped_refptr<TestingPrefStore> selected_store_;
   scoped_refptr<SegregatedPrefStore> segregated_store_;
 
   MockReadErrorDelegate::Data read_error_delegate_data_;
 
  private:
+  void InitializationCallback() {
+    EXPECT_FALSE(observer_.initialized);
+    EXPECT_FALSE(initialization_callback_invoked_);
+    initialization_callback_invoked_ = true;
+  }
+
   scoped_ptr<MockReadErrorDelegate> read_error_delegate_;
 };
 
 TEST_F(SegregatedPrefStoreTest, StoreValues) {
   ASSERT_EQ(PersistentPrefStore::PREF_READ_ERROR_NONE,
             segregated_store_->ReadPrefs());
 
   // Properly stores new values.
   segregated_store_->SetValue(kSelectedPref, new base::StringValue(kValue1));
   segregated_store_->SetValue(kUnselectedPref, new base::StringValue(kValue2));
@@ skipping 28 matching lines @@
 
   ASSERT_TRUE(selected_store_->GetValue(kSelectedPref, NULL));
   ASSERT_FALSE(selected_store_->GetValue(kUnselectedPref, NULL));
   ASSERT_FALSE(default_store_->GetValue(kSelectedPref, NULL));
   ASSERT_TRUE(default_store_->GetValue(kUnselectedPref, NULL));
 
   ASSERT_TRUE(segregated_store_->GetValue(kSelectedPref, NULL));
   ASSERT_TRUE(segregated_store_->GetValue(kUnselectedPref, NULL));
 }
 
+TEST_F(SegregatedPrefStoreTest, PreviouslySelected) {
+  selected_store_->SetValue(kUnselectedPref, new base::StringValue(kValue1));
+  segregated_store_->ReadPrefs();
+  // It will read from the selected store.
+  ASSERT_TRUE(segregated_store_->GetValue(kUnselectedPref, NULL));
+  ASSERT_TRUE(selected_store_->GetValue(kUnselectedPref, NULL));
+  ASSERT_FALSE(default_store_->GetValue(kUnselectedPref, NULL));
+
+  // But when we update the value...
+  segregated_store_->SetValue(kUnselectedPref, new base::StringValue(kValue2));
+  // ...it will be migrated.
+  ASSERT_TRUE(segregated_store_->GetValue(kUnselectedPref, NULL));
+  ASSERT_FALSE(selected_store_->GetValue(kUnselectedPref, NULL));
+  ASSERT_TRUE(default_store_->GetValue(kUnselectedPref, NULL));
+}
+
 TEST_F(SegregatedPrefStoreTest, Observer) {
   EXPECT_EQ(PersistentPrefStore::PREF_READ_ERROR_NONE,
             segregated_store_->ReadPrefs());
+  EXPECT_TRUE(initialization_callback_invoked_);
   EXPECT_TRUE(observer_.initialized);
   EXPECT_TRUE(observer_.initialization_success);
   EXPECT_TRUE(observer_.changed_keys.empty());
   segregated_store_->SetValue(kSelectedPref, new base::StringValue(kValue1));
   observer_.VerifyAndResetChangedKey(kSelectedPref);
   segregated_store_->SetValue(kUnselectedPref, new base::StringValue(kValue2));
   observer_.VerifyAndResetChangedKey(kUnselectedPref);
 }
 
 TEST_F(SegregatedPrefStoreTest, SelectedPrefReadNoFileError) {
@@ skipping 102 matching lines @@
   selected_store_->SetBlockAsyncRead(true);
   default_store_->SetBlockAsyncRead(true);
   EXPECT_FALSE(segregated_store_->IsInitializationComplete());
   segregated_store_->ReadPrefsAsync(NULL);
   EXPECT_FALSE(segregated_store_->IsInitializationComplete());
   selected_store_->SetBlockAsyncRead(false);
   EXPECT_FALSE(segregated_store_->IsInitializationComplete());
   default_store_->SetBlockAsyncRead(false);
   EXPECT_TRUE(segregated_store_->IsInitializationComplete());
 }