detect preferences errors

chrome/browser/pref_service.cc

 // Copyright (c) 2009 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/pref_service.h"
 
 #include <algorithm>
 #include <string>
 
 #include "app/l10n_util.h"
+#include "base/histogram.h"
 #include "base/logging.h"
 #include "base/message_loop.h"
 #include "base/stl_util-inl.h"
 #include "base/string_util.h"
 #include "base/sys_string_conversions.h"
 #include "base/utf_string_conversions.h"
 #include "build/build_config.h"
+#include "chrome/browser/chrome_thread.h"
 #include "chrome/common/json_value_serializer.h"
 #include "chrome/common/notification_service.h"
+#include "grit/chromium_strings.h"
 #include "grit/generated_resources.h"
 
 namespace {
 
 // A helper function for RegisterLocalized*Pref that creates a Value* based on
 // the string value in the locale dll.  Because we control the values in a
 // locale dll, this should always return a Value of the appropriate type.
 Value* CreateLocaleDefaultValue(Value::ValueType type, int message_id) {
   std::wstring resource_string = l10n_util::GetString(message_id);
   DCHECK(!resource_string.empty());
@@ skipping 25 matching lines @@
 
     default: {
       NOTREACHED() <<
           "list and dictionary types can not have default locale values";
     }
   }
   NOTREACHED();
   return Value::CreateNullValue();
 }
 
+// Forwards a notification after a PostMessage so that we can wait for the
+// MessageLoop to run.
+void NotifyReadError(PrefService* pref, int message_id) {
+  Source<PrefService> source(pref);
+  NotificationService::current()->Notify(NotificationType::PROFILE_ERROR,
+                                         source, Details<int>(&message_id));
+}
+
 }  // namespace
 
 PrefService::PrefService(const FilePath& pref_filename)
     : persistent_(new DictionaryValue),
-      writer_(pref_filename) {
-  ReloadPersistentPrefs();
+      writer_(pref_filename),
+      read_only_(false) {
+  InitFromDisk();
 }
 
 PrefService::~PrefService() {
   DCHECK(CalledOnValidThread());
 
   // Verify that there are no pref observers when we shut down.
   for (PrefObserverMap::iterator it = pref_observers_.begin();
        it != pref_observers_.end(); ++it) {
     NotificationObserverList::Iterator obs_iterator(*(it->second));
     if (obs_iterator.GetNext()) {
       LOG(WARNING) << "pref observer found at shutdown " << it->first;
     }
   }
 
   STLDeleteContainerPointers(prefs_.begin(), prefs_.end());
   prefs_.clear();
   STLDeleteContainerPairSecondPointers(pref_observers_.begin(),
                                        pref_observers_.end());
   pref_observers_.clear();
 
-  if (writer_.HasPendingWrite())
+  if (writer_.HasPendingWrite() && !read_only_)
     writer_.DoScheduledWrite();
 }
 
+void PrefService::InitFromDisk() {
+  PrefReadError error = LoadPersistentPrefs();
+  if (error == PREF_READ_ERROR_NONE)
+    return;
+
+  // Failing to load prefs on startup is a bad thing(TM). See bug 38352 for
+  // an example problem that this can cause.
+  // Do some diagnosis and try to avoid losing data.
+  int message_id = 0;
+  if (error <= PREF_READ_ERROR_JSON_TYPE) {
+    // JSON errors indicate file corruption of some sort.
+    // It's possible the user hand-edited the file, so don't clobber it yet.
+    // Give them a chance to recover the file.
+    // TODO(erikkay) maybe we should just move it aside and continue.
+    read_only_ = true;
+    message_id = IDS_PREFERENCES_CORRUPT_ERROR;
+  } if (error == PREF_READ_ERROR_NO_FILE) {
+    // If the file just doesn't exist, maybe this is first run.  In any case
+    // there's no harm in writing out default prefs in this case.
+  } else {
+    // If the file exists but is simply unreadable, put the file into a state
+    // where we don't try to save changes.  Otherwise, we could clobber the
+    // existing prefs.
+    read_only_ = true;
+    message_id = IDS_PREFERENCES_UNREADABLE_ERROR;
+  }
+
+  if (message_id) {
+    ChromeThread::PostTask(ChromeThread::UI, FROM_HERE,
+        NewRunnableFunction(&NotifyReadError, this, message_id));
+  }
+  UMA_HISTOGRAM_ENUMERATION("PrefService.ReadError", error, 20);
+}
+
 bool PrefService::ReloadPersistentPrefs() {
+  return (LoadPersistentPrefs() == PREF_READ_ERROR_NONE);
+}
+
+PrefService::PrefReadError PrefService::LoadPersistentPrefs() {
   DCHECK(CalledOnValidThread());
+  JSONFileValueSerializer serializer(writer_.path());
 
-  JSONFileValueSerializer serializer(writer_.path());
-  scoped_ptr<Value> root(serializer.Deserialize(NULL));
-  if (!root.get())
-    return false;
+  int error_code;
+  std::string error_msg;
+  scoped_ptr<Value> root(serializer.Deserialize(&error_code, &error_msg));
+  if (!root.get()) {
+    PLOG(ERROR) << "Error reading Preferences: " << error_msg << " " <<
+        writer_.path().value();
+    PrefReadError pref_error;
+    switch (error_code) {
+      case JSONFileValueSerializer::JSON_ACCESS_DENIED:
+        pref_error = PREF_READ_ERROR_ACCESS_DENIED;
+        break;
+      case JSONFileValueSerializer::JSON_CANNOT_READ_FILE:
+        pref_error = PREF_READ_ERROR_FILE_OTHER;
+        break;
+      case JSONFileValueSerializer::JSON_FILE_LOCKED:
+        pref_error = PREF_READ_ERROR_FILE_LOCKED;
+        break;
+      case JSONFileValueSerializer::JSON_NO_SUCH_FILE:
+        pref_error = PREF_READ_ERROR_NO_FILE;
+        break;
+      default:
+        pref_error = PREF_READ_ERROR_JSON_PARSE;
+        break;
+    }
+    return pref_error;
+  }
 
   // Preferences should always have a dictionary root.
   if (!root->IsType(Value::TYPE_DICTIONARY))
-    return false;
+    return PREF_READ_ERROR_JSON_TYPE;
 
   persistent_.reset(static_cast<DictionaryValue*>(root.release()));
   for (PreferenceSet::iterator it = prefs_.begin();
        it != prefs_.end(); ++it) {
     (*it)->root_pref_ = persistent_.get();
   }
 
-  return true;
+  return PREF_READ_ERROR_NONE;
 }
 
 bool PrefService::SavePersistentPrefs() {
   DCHECK(CalledOnValidThread());
 
   std::string data;
   if (!SerializeData(&data))
     return false;
 
+  // Lie about our ability to save.
+  if (read_only_)
+    return true;
+
   writer_.WriteNow(data);
   return true;
 }
 
 void PrefService::ScheduleSavePersistentPrefs() {
   DCHECK(CalledOnValidThread());
+
+  if (read_only_)
+    return;
+
   writer_.ScheduleWrite(this);
 }
 
 void PrefService::RegisterBooleanPref(const wchar_t* path,
                                       bool default_value) {
   Preference* pref = new Preference(persistent_.get(), path,
       Value::CreateBooleanValue(default_value));
   RegisterPreference(pref);
 }
 
@@ skipping 553 matching lines @@
   }
 
   // Pref not found, just return the app default.
   return default_value_.get();
 }
 
 bool PrefService::Preference::IsDefaultValue() const {
   DCHECK(default_value_.get());
   return default_value_->Equals(GetValue());
 }