Separate storage for protected preferences into Protected Preferences file.

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 166 matching lines @@
   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) {
+  // PREF_READ_ERROR_NO_FILE for the selected prefs file is silently converted
+  // to PREF_READ_ERROR_NONE.
+  selected_store_->set_read_error(
+      PersistentPrefStore::PREF_READ_ERROR_NO_FILE);
+  EXPECT_EQ(PersistentPrefStore::PREF_READ_ERROR_NONE,
+            segregated_store_->ReadPrefs());
+  EXPECT_EQ(PersistentPrefStore::PREF_READ_ERROR_NONE,
+            segregated_store_->GetReadError());
+}
+
 TEST_F(SegregatedPrefStoreTest, SelectedPrefReadError) {
   selected_store_->set_read_error(
+      PersistentPrefStore::PREF_READ_ERROR_ACCESS_DENIED);
+  EXPECT_EQ(PersistentPrefStore::PREF_READ_ERROR_ACCESS_DENIED,
+            segregated_store_->ReadPrefs());
+  EXPECT_EQ(PersistentPrefStore::PREF_READ_ERROR_ACCESS_DENIED,
+            segregated_store_->GetReadError());
+}
+
+TEST_F(SegregatedPrefStoreTest, SelectedPrefReadNoFileErrorAsync) {
+  // PREF_READ_ERROR_NO_FILE for the selected prefs file is silently converted
+  // to PREF_READ_ERROR_NONE.
+  selected_store_->set_read_error(
+      PersistentPrefStore::PREF_READ_ERROR_NO_FILE);
+
+  default_store_->SetBlockAsyncRead(true);
+
+  EXPECT_FALSE(read_error_delegate_data_.invoked);
+
+  segregated_store_->ReadPrefsAsync(GetReadErrorDelegate().release());
+
+  EXPECT_FALSE(read_error_delegate_data_.invoked);
+
+  default_store_->SetBlockAsyncRead(false);
+
+  // ReadErrorDelegate is not invoked for ERROR_NONE.
+  EXPECT_FALSE(read_error_delegate_data_.invoked);
+  EXPECT_EQ(PersistentPrefStore::PREF_READ_ERROR_NONE,
+            segregated_store_->GetReadError());
+  EXPECT_EQ(PersistentPrefStore::PREF_READ_ERROR_NONE,
+            segregated_store_->GetReadError());
+}
+
+TEST_F(SegregatedPrefStoreTest, UnselectedPrefReadNoFileError) {
+  default_store_->set_read_error(
       PersistentPrefStore::PREF_READ_ERROR_NO_FILE);
   EXPECT_EQ(PersistentPrefStore::PREF_READ_ERROR_NO_FILE,
             segregated_store_->ReadPrefs());
   EXPECT_EQ(PersistentPrefStore::PREF_READ_ERROR_NO_FILE,
             segregated_store_->GetReadError());
 }
 
 TEST_F(SegregatedPrefStoreTest, UnselectedPrefReadError) {
   default_store_->set_read_error(
-      PersistentPrefStore::PREF_READ_ERROR_NO_FILE);
-  EXPECT_EQ(PersistentPrefStore::PREF_READ_ERROR_NO_FILE,
+      PersistentPrefStore::PREF_READ_ERROR_ACCESS_DENIED);
+  EXPECT_EQ(PersistentPrefStore::PREF_READ_ERROR_ACCESS_DENIED,
             segregated_store_->ReadPrefs());
-  EXPECT_EQ(PersistentPrefStore::PREF_READ_ERROR_NO_FILE,
+  EXPECT_EQ(PersistentPrefStore::PREF_READ_ERROR_ACCESS_DENIED,
             segregated_store_->GetReadError());
 }
 
 TEST_F(SegregatedPrefStoreTest, BothPrefReadError) {
   default_store_->set_read_error(
       PersistentPrefStore::PREF_READ_ERROR_NO_FILE);
   selected_store_->set_read_error(
       PersistentPrefStore::PREF_READ_ERROR_ACCESS_DENIED);
   EXPECT_EQ(PersistentPrefStore::PREF_READ_ERROR_NO_FILE,
             segregated_store_->ReadPrefs());
@@ skipping 34 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());
 }