Merge Chromium at 7.0.540.0 : Fix chrome/browser/prefs

These files were edited in Android but moved in Chromium,
and git wasn't able to resolve all the changes. I've tried
to replicate the original Android code and avoid dragging
in any extra dependencies.

In PrefService, all calls to PrefNotifier are stripped out.

In PrefValueStore, all stores except the trivial DefaultPrefStore
are stripped out.

See http://src.chromium.org/viewvc/chrome?view=rev&revision=57434

Change-Id: I624498c9503e0bacf4ec9c0956af11ba89219139

6 files changed, 51 insertions, 1199 deletions

diff --git a/chrome/browser/pref_service.cc b/chrome/browser/pref_service.cc
deleted file mode 100644
index 46c4a42..0000000
--- a/chrome/browser/pref_service.cc
+++ /dev/null
@@ -1,919 +0,0 @@
-// Copyright (c) 2010 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>
-
-#ifndef ANDROID
-// FIXME: Do we need this on Android?
-#include "app/l10n_util.h"
-#endif
-#ifndef ANDROID
-#include "base/command_line.h"
-#endif
-#include "base/histogram.h"
-#include "base/logging.h"
-#include "base/message_loop.h"
-#include "base/path_service.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"
-#ifndef ANDROID
-#include "chrome/browser/chrome_thread.h"
-#endif
-
-#if defined(OS_WIN)
-#include "chrome/browser/configuration_policy_provider_win.h"
-#elif defined(OS_MACOSX)
-#include "chrome/browser/configuration_policy_provider_mac.h"
-#elif defined(OS_POSIX)
-#include "chrome/browser/config_dir_policy_provider.h"
-#endif
-#include "chrome/browser/dummy_configuration_policy_provider.h"
-
-#include "chrome/browser/command_line_pref_store.h"
-#include "chrome/browser/configuration_policy_pref_store.h"
-#include "chrome/browser/extensions/extension_pref_store.h"
-#include "chrome/common/chrome_paths.h"
-#include "chrome/common/json_pref_store.h"
-#ifndef ANDROID
-// Notifications do not compile on Android and are the cause
-// of most of the ANDROID guards in this file.
-#include "chrome/common/notification_service.h"
-#include "grit/chromium_strings.h"
-#include "grit/generated_resources.h"
-#endif
-
-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) {
-#ifndef ANDROID
-  std::wstring resource_string = l10n_util::GetString(message_id);
-  DCHECK(!resource_string.empty());
-  switch (type) {
-    case Value::TYPE_BOOLEAN: {
-      if (L"true" == resource_string)
-        return Value::CreateBooleanValue(true);
-      if (L"false" == resource_string)
-        return Value::CreateBooleanValue(false);
-      break;
-    }
-
-    case Value::TYPE_INTEGER: {
-      return Value::CreateIntegerValue(
-          StringToInt(WideToUTF16Hack(resource_string)));
-      break;
-    }
-
-    case Value::TYPE_REAL: {
-      return Value::CreateRealValue(
-          StringToDouble(WideToUTF16Hack(resource_string)));
-      break;
-    }
-
-    case Value::TYPE_STRING: {
-      return Value::CreateStringValue(resource_string);
-      break;
-    }
-
-    default: {
-      NOTREACHED() <<
-          "list and dictionary types can not have default locale values";
-    }
-  }
-#endif
-  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) {
-#ifndef ANDROID
-  Source<PrefService> source(pref);
-  NotificationService::current()->Notify(NotificationType::PROFILE_ERROR,
-                                         source, Details<int>(&message_id));
-#endif
-}
-
-}  // namespace
-
-// static
-PrefService* PrefService::CreatePrefService(const FilePath& pref_filename) {
-  PrefStore* managed_prefs = NULL;
-  // TODO(pamg): Reinstate extension pref store after Mstone6 branch, when its
-  // memory leaks are fixed and any extension API is using it.
-  // ExtensionPrefStore* extension_prefs = new ExtensionPrefStore(NULL);
-  ExtensionPrefStore* extension_prefs = NULL;
-#ifdef ANDROID
-  CommandLinePrefStore* command_line_prefs = NULL;
-#else
-  CommandLinePrefStore* command_line_prefs = new CommandLinePrefStore(
-      CommandLine::ForCurrentProcess());
-#endif
-
-#ifdef ANDROID
-  PrefStore* local_prefs = NULL;
-#else
-  PrefStore* local_prefs = new JsonPrefStore(
-      pref_filename,
-      ChromeThread::GetMessageLoopProxyForThread(ChromeThread::FILE));
-#endif
-  PrefStore* recommended_prefs = NULL;
-
-  ConfigurationPolicyProvider* managed_prefs_provider = NULL;
-  ConfigurationPolicyProvider* recommended_prefs_provider = NULL;
-
-#if defined(OS_WIN)
-  managed_prefs_provider = new ConfigurationPolicyProviderWin();
-  recommended_prefs_provider = new DummyConfigurationPolicyProvider();
-#elif defined(OS_MACOSX)
-  managed_prefs_provider = new ConfigurationPolicyProviderMac();
-  recommended_prefs_provider = new DummyConfigurationPolicyProvider();
-#elif defined(OS_POSIX)
-  FilePath config_dir_path;
-  if (PathService::Get(chrome::DIR_POLICY_FILES, &config_dir_path)) {
-    managed_prefs_provider = new ConfigDirPolicyProvider(
-        config_dir_path.Append(FILE_PATH_LITERAL("managed")));
-    recommended_prefs_provider = new ConfigDirPolicyProvider(
-        config_dir_path.Append(FILE_PATH_LITERAL("recommended")));
-  } else {
-    managed_prefs_provider = new DummyConfigurationPolicyProvider();
-    recommended_prefs_provider = new DummyConfigurationPolicyProvider();
-  }
-#endif
-
-#ifdef ANDROID
-  managed_prefs = NULL;
-  recommended_prefs = NULL;
-#else
-  // The ConfigurationPolicyPrefStore takes ownership of the passed
-  // |provider|.
-  managed_prefs = new ConfigurationPolicyPrefStore(
-      CommandLine::ForCurrentProcess(),
-      managed_prefs_provider);
-  recommended_prefs = new ConfigurationPolicyPrefStore(
-      CommandLine::ForCurrentProcess(),
-      recommended_prefs_provider);
-#endif
-
-  // The PrefValueStore takes ownership of the PrefStores.
-  PrefValueStore* value_store = new PrefValueStore(
-      managed_prefs,
-      extension_prefs,
-      command_line_prefs,
-      local_prefs,
-      recommended_prefs);
-
-  PrefService* pref_service = new PrefService(value_store);
-  // TODO(pamg): Uncomment when ExtensionPrefStore is reinstated.
-  // extension_prefs->SetPrefService(pref_service);
-
-  return pref_service;
-}
-
-// static
-PrefService* PrefService::CreateUserPrefService(
-    const FilePath& pref_filename) {
-  PrefValueStore* value_store = new PrefValueStore(
-      NULL, /* no enforced prefs */
-      NULL, /* no extension prefs */
-      NULL, /* no command-line prefs */
-#ifdef ANDROID
-      NULL, /* no user prefs */
-#else
-      new JsonPrefStore(
-          pref_filename,
-          ChromeThread::GetMessageLoopProxyForThread(ChromeThread::FILE)),
-          /* user prefs */
-#endif
-      NULL /* no advised prefs */);
-  return new PrefService(value_store);
-}
-
-PrefService::PrefService(PrefValueStore* pref_value_store)
-    : pref_value_store_(pref_value_store) {
-  InitFromStorage();
-}
-
-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();
-}
-
-void PrefService::InitFromStorage() {
-#ifdef ANDROID
-  // Don't use pref storage on Android.
-  // TODO: see if we can remove this entire class.
-#else
-  PrefStore::PrefReadError error = LoadPersistentPrefs();
-  if (error == PrefStore::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 <= PrefStore::PREF_READ_ERROR_JSON_TYPE) {
-    message_id = IDS_PREFERENCES_CORRUPT_ERROR;
-  } else if (error != PrefStore::PREF_READ_ERROR_NO_FILE) {
-    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);
-#endif
-}
-
-bool PrefService::ReloadPersistentPrefs() {
-  return (LoadPersistentPrefs() == PrefStore::PREF_READ_ERROR_NONE);
-}
-
-PrefStore::PrefReadError PrefService::LoadPersistentPrefs() {
-  DCHECK(CalledOnValidThread());
-
-  PrefStore::PrefReadError pref_error = pref_value_store_->ReadPrefs();
-
-  for (PreferenceSet::iterator it = prefs_.begin();
-       it != prefs_.end(); ++it) {
-    (*it)->pref_value_store_ = pref_value_store_.get();
-  }
-
-  return pref_error;
-}
-
-bool PrefService::SavePersistentPrefs() {
-  DCHECK(CalledOnValidThread());
-
-  return pref_value_store_->WritePrefs();
-}
-
-void PrefService::ScheduleSavePersistentPrefs() {
-  DCHECK(CalledOnValidThread());
-
-  pref_value_store_->ScheduleWritePrefs();
-}
-
-void PrefService::RegisterBooleanPref(const wchar_t* path,
-                                      bool default_value) {
-  Preference* pref = new Preference(pref_value_store_.get(), path,
-      Value::CreateBooleanValue(default_value));
-  RegisterPreference(pref);
-}
-
-void PrefService::RegisterIntegerPref(const wchar_t* path,
-                                      int default_value) {
-  Preference* pref = new Preference(pref_value_store_.get(), path,
-      Value::CreateIntegerValue(default_value));
-  RegisterPreference(pref);
-}
-
-void PrefService::RegisterRealPref(const wchar_t* path,
-                                   double default_value) {
-  Preference* pref = new Preference(pref_value_store_.get(), path,
-      Value::CreateRealValue(default_value));
-  RegisterPreference(pref);
-}
-
-void PrefService::RegisterStringPref(const wchar_t* path,
-                                     const std::string& default_value) {
-  Preference* pref = new Preference(pref_value_store_.get(), path,
-      Value::CreateStringValue(default_value));
-  RegisterPreference(pref);
-}
-
-void PrefService::RegisterFilePathPref(const wchar_t* path,
-                                       const FilePath& default_value) {
-  Preference* pref = new Preference(pref_value_store_.get(), path,
-      Value::CreateStringValue(default_value.value()));
-  RegisterPreference(pref);
-}
-
-void PrefService::RegisterListPref(const wchar_t* path) {
-  Preference* pref = new Preference(pref_value_store_.get(), path,
-      new ListValue);
-  RegisterPreference(pref);
-}
-
-void PrefService::RegisterDictionaryPref(const wchar_t* path) {
-  Preference* pref = new Preference(pref_value_store_.get(), path,
-      new DictionaryValue());
-  RegisterPreference(pref);
-}
-
-void PrefService::RegisterLocalizedBooleanPref(const wchar_t* path,
-                                               int locale_default_message_id) {
-  Preference* pref = new Preference(pref_value_store_.get(), path,
-      CreateLocaleDefaultValue(Value::TYPE_BOOLEAN, locale_default_message_id));
-  RegisterPreference(pref);
-}
-
-void PrefService::RegisterLocalizedIntegerPref(const wchar_t* path,
-                                               int locale_default_message_id) {
-  Preference* pref = new Preference(pref_value_store_.get(), path,
-      CreateLocaleDefaultValue(Value::TYPE_INTEGER, locale_default_message_id));
-  RegisterPreference(pref);
-}
-
-void PrefService::RegisterLocalizedRealPref(const wchar_t* path,
-                                            int locale_default_message_id) {
-  Preference* pref = new Preference(pref_value_store_.get(), path,
-      CreateLocaleDefaultValue(Value::TYPE_REAL, locale_default_message_id));
-  RegisterPreference(pref);
-}
-
-void PrefService::RegisterLocalizedStringPref(const wchar_t* path,
-                                              int locale_default_message_id) {
-  Preference* pref = new Preference(pref_value_store_.get(), path,
-      CreateLocaleDefaultValue(Value::TYPE_STRING, locale_default_message_id));
-  RegisterPreference(pref);
-}
-
-bool PrefService::GetBoolean(const wchar_t* path) const {
-  DCHECK(CalledOnValidThread());
-
-  bool result = false;
-
-  const Preference* pref = FindPreference(path);
-  if (!pref) {
-    NOTREACHED() << "Trying to read an unregistered pref: " << path;
-    return result;
-  }
-  bool rv = pref->GetValue()->GetAsBoolean(&result);
-  DCHECK(rv);
-  return result;
-}
-
-int PrefService::GetInteger(const wchar_t* path) const {
-  DCHECK(CalledOnValidThread());
-
-  int result = 0;
-
-  const Preference* pref = FindPreference(path);
-  if (!pref) {
-    NOTREACHED() << "Trying to read an unregistered pref: " << path;
-    return result;
-  }
-  bool rv = pref->GetValue()->GetAsInteger(&result);
-  DCHECK(rv);
-  return result;
-}
-
-double PrefService::GetReal(const wchar_t* path) const {
-  DCHECK(CalledOnValidThread());
-
-  double result = 0.0;
-
-  const Preference* pref = FindPreference(path);
-  if (!pref) {
-    NOTREACHED() << "Trying to read an unregistered pref: " << path;
-    return result;
-  }
-  bool rv = pref->GetValue()->GetAsReal(&result);
-  DCHECK(rv);
-  return result;
-}
-
-std::string PrefService::GetString(const wchar_t* path) const {
-  DCHECK(CalledOnValidThread());
-
-  std::string result;
-
-  const Preference* pref = FindPreference(path);
-  if (!pref) {
-    NOTREACHED() << "Trying to read an unregistered pref: " << path;
-    return result;
-  }
-  bool rv = pref->GetValue()->GetAsString(&result);
-  DCHECK(rv);
-  return result;
-}
-
-FilePath PrefService::GetFilePath(const wchar_t* path) const {
-  DCHECK(CalledOnValidThread());
-
-  FilePath::StringType result;
-
-  const Preference* pref = FindPreference(path);
-  if (!pref) {
-    NOTREACHED() << "Trying to read an unregistered pref: " << path;
-    return FilePath(result);
-  }
-  bool rv = pref->GetValue()->GetAsString(&result);
-  DCHECK(rv);
-#if defined(OS_POSIX)
-  // We store filepaths as UTF8, so convert it back to the system type.
-  result = base::SysWideToNativeMB(UTF8ToWide(result));
-#endif
-  return FilePath(result);
-}
-
-bool PrefService::HasPrefPath(const wchar_t* path) const {
-  return pref_value_store_->HasPrefPath(path);
-}
-
-const PrefService::Preference* PrefService::FindPreference(
-    const wchar_t* pref_name) const {
-  DCHECK(CalledOnValidThread());
-  Preference p(NULL, pref_name, NULL);
-  PreferenceSet::const_iterator it = prefs_.find(&p);
-  return it == prefs_.end() ? NULL : *it;
-}
-
-bool PrefService::IsManagedPreference(const wchar_t* pref_name) const {
-  const Preference* pref = FindPreference(pref_name);
-  if (pref && pref->IsManaged()) {
-    return true;
-  }
-  return false;
-}
-
-void PrefService::FireObserversIfChanged(const wchar_t* path,
-                                         const Value* old_value) {
-  if (PrefIsChanged(path, old_value))
-    FireObservers(path);
-}
-
-void PrefService::FireObservers(const wchar_t* path) {
-  DCHECK(CalledOnValidThread());
-#ifndef ANDROID
-  // Convert path to a std::wstring because the Details constructor requires a
-  // class.
-  std::wstring path_str(path);
-  PrefObserverMap::iterator observer_iterator = pref_observers_.find(path_str);
-  if (observer_iterator == pref_observers_.end())
-    return;
-
-  NotificationObserverList::Iterator it(*(observer_iterator->second));
-  NotificationObserver* observer;
-  while ((observer = it.GetNext()) != NULL) {
-    observer->Observe(NotificationType::PREF_CHANGED,
-                      Source<PrefService>(this),
-                      Details<std::wstring>(&path_str));
-  }
-#endif
-}
-
-bool PrefService::PrefIsChanged(const wchar_t* path,
-                                const Value* old_value) {
-  Value* new_value = NULL;
-  pref_value_store_->GetValue(path, &new_value);
-  // Some unit tests have no values for certain prefs.
-  return (!new_value || !old_value->Equals(new_value));
-}
-
-const DictionaryValue* PrefService::GetDictionary(const wchar_t* path) const {
-  DCHECK(CalledOnValidThread());
-
-  const Preference* pref = FindPreference(path);
-  if (!pref) {
-    NOTREACHED() << "Trying to read an unregistered pref: " << path;
-    return NULL;
-  }
-  const Value* value = pref->GetValue();
-  if (value->GetType() == Value::TYPE_NULL)
-    return NULL;
-  return static_cast<const DictionaryValue*>(value);
-}
-
-const ListValue* PrefService::GetList(const wchar_t* path) const {
-  DCHECK(CalledOnValidThread());
-
-  const Preference* pref = FindPreference(path);
-  if (!pref) {
-    NOTREACHED() << "Trying to read an unregistered pref: " << path;
-    return NULL;
-  }
-  const Value* value = pref->GetValue();
-  if (value->GetType() == Value::TYPE_NULL)
-    return NULL;
-  return static_cast<const ListValue*>(value);
-}
-
-void PrefService::AddPrefObserver(const wchar_t* path,
-                                  NotificationObserver* obs) {
-  DCHECK(CalledOnValidThread());
-
-#ifndef ANDROID
-  const Preference* pref = FindPreference(path);
-  if (!pref) {
-    NOTREACHED() << "Trying to add an observer for an unregistered pref: "
-        << path;
-    return;
-  }
-
-  // Get the pref observer list associated with the path.
-  NotificationObserverList* observer_list = NULL;
-  PrefObserverMap::iterator observer_iterator = pref_observers_.find(path);
-  if (observer_iterator == pref_observers_.end()) {
-    observer_list = new NotificationObserverList;
-    pref_observers_[path] = observer_list;
-  } else {
-    observer_list = observer_iterator->second;
-  }
-
-  // Verify that this observer doesn't already exist.
-  NotificationObserverList::Iterator it(*observer_list);
-  NotificationObserver* existing_obs;
-  while ((existing_obs = it.GetNext()) != NULL) {
-    DCHECK(existing_obs != obs) << path << " observer already registered";
-    if (existing_obs == obs)
-      return;
-  }
-
-  // Ok, safe to add the pref observer.
-  observer_list->AddObserver(obs);
-#endif
-}
-
-void PrefService::RemovePrefObserver(const wchar_t* path,
-                                     NotificationObserver* obs) {
-  DCHECK(CalledOnValidThread());
-
-#ifndef ANDROID
-  PrefObserverMap::iterator observer_iterator = pref_observers_.find(path);
-  if (observer_iterator == pref_observers_.end()) {
-    return;
-  }
-
-  NotificationObserverList* observer_list = observer_iterator->second;
-  observer_list->RemoveObserver(obs);
-#endif
-}
-
-void PrefService::RegisterPreference(Preference* pref) {
-  DCHECK(CalledOnValidThread());
-
-  if (FindPreference(pref->name().c_str())) {
-    NOTREACHED() << "Tried to register duplicate pref " << pref->name();
-    delete pref;
-    return;
-  }
-  prefs_.insert(pref);
-}
-
-void PrefService::ClearPref(const wchar_t* path) {
-  DCHECK(CalledOnValidThread());
-
-  const Preference* pref = FindPreference(path);
-  if (!pref) {
-    NOTREACHED() << "Trying to clear an unregistered pref: " << path;
-    return;
-  }
-  Value* value;
-  bool has_old_value = pref_value_store_->GetValue(path, &value);
-  pref_value_store_->RemoveUserPrefValue(path);
-
-  if (has_old_value)
-    FireObservers(path);
-}
-
-void PrefService::Set(const wchar_t* path, const Value& value) {
-  DCHECK(CalledOnValidThread());
-
-  const Preference* pref = FindPreference(path);
-  if (!pref) {
-    NOTREACHED() << "Trying to write an unregistered pref: " << path;
-    return;
-  }
-
-  // Allow dictionary and list types to be set to null.
-  if (value.GetType() == Value::TYPE_NULL &&
-      (pref->type() == Value::TYPE_DICTIONARY ||
-       pref->type() == Value::TYPE_LIST)) {
-    scoped_ptr<Value> old_value(GetPrefCopy(path));
-    if (!old_value->Equals(&value)) {
-      pref_value_store_->RemoveUserPrefValue(path);
-      FireObservers(path);
-    }
-    return;
-  }
-
-  if (pref->type() != value.GetType()) {
-    NOTREACHED() << "Wrong type for Set: " << path;
-  }
-
-  scoped_ptr<Value> old_value(GetPrefCopy(path));
-  pref_value_store_->SetUserPrefValue(path, value.DeepCopy());
-
-  FireObserversIfChanged(path, old_value.get());
-}
-
-void PrefService::SetBoolean(const wchar_t* path, bool value) {
-  DCHECK(CalledOnValidThread());
-
-  const Preference* pref = FindPreference(path);
-  if (!pref) {
-    NOTREACHED() << "Trying to write an unregistered pref: " << path;
-    return;
-  }
-  if (pref->IsManaged()) {
-    NOTREACHED() << "Preference is managed: " << path;
-    return;
-  }
-  if (pref->type() != Value::TYPE_BOOLEAN) {
-    NOTREACHED() << "Wrong type for SetBoolean: " << path;
-    return;
-  }
-
-  scoped_ptr<Value> old_value(GetPrefCopy(path));
-  Value* new_value = Value::CreateBooleanValue(value);
-  pref_value_store_->SetUserPrefValue(path, new_value);
-
-  FireObserversIfChanged(path, old_value.get());
-}
-
-void PrefService::SetInteger(const wchar_t* path, int value) {
-  DCHECK(CalledOnValidThread());
-
-  const Preference* pref = FindPreference(path);
-  if (!pref) {
-    NOTREACHED() << "Trying to write an unregistered pref: " << path;
-    return;
-  }
-  if (pref->IsManaged()) {
-    NOTREACHED() << "Preference is managed: " << path;
-    return;
-  }
-  if (pref->type() != Value::TYPE_INTEGER) {
-    NOTREACHED() << "Wrong type for SetInteger: " << path;
-    return;
-  }
-
-  scoped_ptr<Value> old_value(GetPrefCopy(path));
-  Value* new_value = Value::CreateIntegerValue(value);
-  pref_value_store_->SetUserPrefValue(path, new_value);
-
-  FireObserversIfChanged(path, old_value.get());
-}
-
-void PrefService::SetReal(const wchar_t* path, double value) {
-  DCHECK(CalledOnValidThread());
-
-  const Preference* pref = FindPreference(path);
-  if (!pref) {
-    NOTREACHED() << "Trying to write an unregistered pref: " << path;
-    return;
-  }
-  if (pref->IsManaged()) {
-    NOTREACHED() << "Preference is managed: " << path;
-    return;
-  }
-  if (pref->type() != Value::TYPE_REAL) {
-    NOTREACHED() << "Wrong type for SetReal: " << path;
-    return;
-  }
-
-  scoped_ptr<Value> old_value(GetPrefCopy(path));
-  Value* new_value = Value::CreateRealValue(value);
-  pref_value_store_->SetUserPrefValue(path, new_value);
-
-  FireObserversIfChanged(path, old_value.get());
-}
-
-void PrefService::SetString(const wchar_t* path, const std::string& value) {
-  DCHECK(CalledOnValidThread());
-
-  const Preference* pref = FindPreference(path);
-  if (!pref) {
-    NOTREACHED() << "Trying to write an unregistered pref: " << path;
-    return;
-  }
-  if (pref->IsManaged()) {
-    NOTREACHED() << "Preference is managed: " << path;
-    return;
-  }
-  if (pref->type() != Value::TYPE_STRING) {
-    NOTREACHED() << "Wrong type for SetString: " << path;
-    return;
-  }
-
-  scoped_ptr<Value> old_value(GetPrefCopy(path));
-  Value* new_value = Value::CreateStringValue(value);
-  pref_value_store_->SetUserPrefValue(path, new_value);
-
-  FireObserversIfChanged(path, old_value.get());
-}
-
-void PrefService::SetFilePath(const wchar_t* path, const FilePath& value) {
-  DCHECK(CalledOnValidThread());
-
-  const Preference* pref = FindPreference(path);
-  if (!pref) {
-    NOTREACHED() << "Trying to write an unregistered pref: " << path;
-    return;
-  }
-  if (pref->IsManaged()) {
-    NOTREACHED() << "Preference is managed: " << path;
-    return;
-  }
-  if (pref->type() != Value::TYPE_STRING) {
-    NOTREACHED() << "Wrong type for SetFilePath: " << path;
-    return;
-  }
-
-  scoped_ptr<Value> old_value(GetPrefCopy(path));
-#if defined(OS_POSIX)
-  // Value::SetString only knows about UTF8 strings, so convert the path from
-  // the system native value to UTF8.
-  std::string path_utf8 = WideToUTF8(base::SysNativeMBToWide(value.value()));
-  Value* new_value = Value::CreateStringValue(path_utf8);
-  pref_value_store_->SetUserPrefValue(path, new_value);
-#else
-  Value* new_value = Value::CreateStringValue(value.value());
-  pref_value_store_->SetUserPrefValue(path, new_value);
-#endif
-
-  FireObserversIfChanged(path, old_value.get());
-}
-
-void PrefService::SetInt64(const wchar_t* path, int64 value) {
-  DCHECK(CalledOnValidThread());
-
-  const Preference* pref = FindPreference(path);
-  if (!pref) {
-    NOTREACHED() << "Trying to write an unregistered pref: " << path;
-    return;
-  }
-  if (pref->IsManaged()) {
-    NOTREACHED() << "Preference is managed: " << path;
-    return;
-  }
-  if (pref->type() != Value::TYPE_STRING) {
-    NOTREACHED() << "Wrong type for SetInt64: " << path;
-    return;
-  }
-
-  scoped_ptr<Value> old_value(GetPrefCopy(path));
-  Value* new_value = Value::CreateStringValue(Int64ToWString(value));
-  pref_value_store_->SetUserPrefValue(path, new_value);
-
-  FireObserversIfChanged(path, old_value.get());
-}
-
-int64 PrefService::GetInt64(const wchar_t* path) const {
-  DCHECK(CalledOnValidThread());
-
-  const Preference* pref = FindPreference(path);
-  if (!pref) {
-    NOTREACHED() << "Trying to read an unregistered pref: " << path;
-    return 0;
-  }
-  std::wstring result(L"0");
-  bool rv = pref->GetValue()->GetAsString(&result);
-  DCHECK(rv);
-  return StringToInt64(WideToUTF16Hack(result));
-}
-
-void PrefService::RegisterInt64Pref(const wchar_t* path, int64 default_value) {
-  Preference* pref = new Preference(pref_value_store_.get(), path,
-      Value::CreateStringValue(Int64ToWString(default_value)));
-  RegisterPreference(pref);
-}
-
-DictionaryValue* PrefService::GetMutableDictionary(const wchar_t* path) {
-  DCHECK(CalledOnValidThread());
-
-  const Preference* pref = FindPreference(path);
-  if (!pref) {
-    NOTREACHED() << "Trying to get an unregistered pref: " << path;
-    return NULL;
-  }
-  if (pref->type() != Value::TYPE_DICTIONARY) {
-    NOTREACHED() << "Wrong type for GetMutableDictionary: " << path;
-    return NULL;
-  }
-
-  DictionaryValue* dict = NULL;
-  Value* tmp_value = NULL;
-  if (!pref_value_store_->GetValue(path, &tmp_value) ||
-      !tmp_value->IsType(Value::TYPE_DICTIONARY)) {
-    dict = new DictionaryValue;
-    pref_value_store_->SetUserPrefValue(path, dict);
-  } else {
-    dict = static_cast<DictionaryValue*>(tmp_value);
-  }
-  return dict;
-}
-
-ListValue* PrefService::GetMutableList(const wchar_t* path) {
-  DCHECK(CalledOnValidThread());
-
-  const Preference* pref = FindPreference(path);
-  if (!pref) {
-    NOTREACHED() << "Trying to get an unregistered pref: " << path;
-    return NULL;
-  }
-  if (pref->type() != Value::TYPE_LIST) {
-    NOTREACHED() << "Wrong type for GetMutableList: " << path;
-    return NULL;
-  }
-
-  ListValue* list = NULL;
-  Value* tmp_value = NULL;
-  if (!pref_value_store_->GetValue(path, &tmp_value)) {
-    list = new ListValue;
-    pref_value_store_->SetUserPrefValue(path, list);
-  } else {
-    list = static_cast<ListValue*>(tmp_value);
-  }
-  return list;
-}
-
-Value* PrefService::GetPrefCopy(const wchar_t* path) {
-  DCHECK(CalledOnValidThread());
-
-  const Preference* pref = FindPreference(path);
-  DCHECK(pref);
-  return pref->GetValue()->DeepCopy();
-}
-
-///////////////////////////////////////////////////////////////////////////////
-// PrefService::Preference
-
-PrefService::Preference::Preference(PrefValueStore* pref_value_store,
-                                    const wchar_t* name,
-                                    Value* default_value)
-      : type_(Value::TYPE_NULL),
-        name_(name),
-        default_value_(default_value),
-        pref_value_store_(pref_value_store) {
-  DCHECK(name);
-
-  if (default_value) {
-    type_ = default_value->GetType();
-    DCHECK(type_ != Value::TYPE_NULL && type_ != Value::TYPE_BINARY) <<
-        "invalid preference type: " << type_;
-  }
-
-  // We set the default value of lists and dictionaries to be null so it's
-  // easier for callers to check for empty list/dict prefs.
-  if (Value::TYPE_LIST == type_ || Value::TYPE_DICTIONARY == type_)
-    default_value_.reset(Value::CreateNullValue());
-}
-
-const Value* PrefService::Preference::GetValue() const {
-  DCHECK(NULL != pref_value_store_) <<
-      "Must register pref before getting its value";
-
-  Value* temp_value = NULL;
-  if (pref_value_store_->GetValue(name_, &temp_value) &&
-      temp_value->GetType() == type_) {
-    return temp_value;
-  }
-
-  // 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());
-}
-
-bool PrefService::Preference::IsManaged() const {
-  return pref_value_store_->PrefValueInManagedStore(name_.c_str());
-}
-
-bool PrefService::Preference::HasExtensionSetting() const {
-  return pref_value_store_->PrefValueInExtensionStore(name_.c_str());
-}
-
-bool PrefService::Preference::HasUserSetting() const {
-  return pref_value_store_->PrefValueInUserStore(name_.c_str());
-}
-
-bool PrefService::Preference::IsExtensionControlled() const {
-  return pref_value_store_->PrefValueFromExtensionStore(name_.c_str());
-}
-
-bool PrefService::Preference::IsUserControlled() const {
-  return pref_value_store_->PrefValueFromUserStore(name_.c_str());
-}
-
-bool PrefService::Preference::IsUserModifiable() const {
-  return pref_value_store_->PrefValueUserModifiable(name_.c_str());
-}
diff --git a/chrome/browser/pref_service.h b/chrome/browser/pref_service.h
deleted file mode 100644
index 2d50747..0000000
--- a/chrome/browser/pref_service.h
+++ /dev/null
@@ -1,278 +0,0 @@
-// Copyright (c) 2010 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.
-
-// This provides a way to access the application's current preferences.
-
-#ifndef CHROME_BROWSER_PREF_SERVICE_H_
-#define CHROME_BROWSER_PREF_SERVICE_H_
-
-#include <set>
-
-#include "base/file_path.h"
-#include "base/hash_tables.h"
-#include "base/non_thread_safe.h"
-#include "base/observer_list.h"
-#include "base/scoped_ptr.h"
-#include "base/values.h"
-#include "chrome/browser/pref_value_store.h"
-#include "chrome/common/pref_store.h"
-
-class NotificationObserver;
-class Preference;
-class ScopedPrefUpdate;
-
-class PrefService : public NonThreadSafe {
- public:
-
-  // A helper class to store all the information associated with a preference.
-  class Preference {
-   public:
-
-    // The type of the preference is determined by the type of |default_value|.
-    // Therefore, the type needs to be a boolean, integer, real, string,
-    // dictionary (a branch), or list.  You shouldn't need to construct this on
-    // your own, use the PrefService::Register*Pref methods instead.
-    // |default_value| will be owned by the Preference object.
-    Preference(PrefValueStore* pref_value_store,
-               const wchar_t* name,
-               Value* default_value);
-    ~Preference() {}
-
-    Value::ValueType type() const { return type_; }
-
-    // Returns the name of the Preference (i.e., the key, e.g.,
-    // browser.window_placement).
-    const std::wstring name() const { return name_; }
-
-    // Returns the value of the Preference.  If there is no user specified
-    // value, it returns the default value.
-    const Value* GetValue() const;
-
-    // Returns true if the current value matches the default value.
-    bool IsDefaultValue() const;
-
-    // Returns true if the Preference is managed, i.e. set by an admin policy.
-    // Since managed prefs have the highest priority, this also indicates
-    // whether the pref is actually being controlled by the policy setting.
-    bool IsManaged() const;
-
-    // Returns true if the Preference has a value set by an extension, even if
-    // that value is being overridden by a higher-priority source.
-    bool HasExtensionSetting() const;
-
-    // Returns true if the Preference has a user setting, even if that value is
-    // being overridden by a higher-priority source.
-    bool HasUserSetting() const;
-
-    // Returns true if the Preference value is currently being controlled by an
-    // extension, and not by any higher-priority source.
-    bool IsExtensionControlled() const;
-
-    // Returns true if the Preference value is currently being controlled by a
-    // user setting, and not by any higher-priority source.
-    bool IsUserControlled() const;
-
-    // Returns true if the user can change the Preference value, which is the
-    // case if no higher-priority source than the user store controls the
-    // Preference.
-    bool IsUserModifiable() const;
-
-   private:
-    friend class PrefService;
-
-    Value::ValueType type_;
-    std::wstring name_;
-    scoped_ptr<Value> default_value_;
-
-    // A reference to the pref service's pref_value_store_.
-    PrefValueStore* pref_value_store_;
-
-    DISALLOW_COPY_AND_ASSIGN(Preference);
-  };
-
-  // Factory method that creates a new instance of a |PrefService| with
-  // all platform-applicable PrefStores (managed, extension, user, etc.).
-  // This is the usual way to create a new PrefService.
-  static PrefService* CreatePrefService(const FilePath& pref_filename);
-
-  // Convenience factory method for use in unit tests. Creates a new
-  // PrefService that uses a PrefValueStore with user preferences at the given
-  // |pref_filename|, and no other PrefStores (i.e., no other types of
-  // preferences).
-  static PrefService* CreateUserPrefService(const FilePath& pref_filename);
-
-  // This constructor is primarily used by tests. The |PrefValueStore| provides
-  // preference values.
-  explicit PrefService(PrefValueStore* pref_value_store);
-
-#ifdef ANDROID
-  // TODO: Upstream
-  virtual
-#endif
-  ~PrefService();
-
-  // Reloads the data from file. This should only be called when the importer
-  // is running during first run, and the main process may not change pref
-  // values while the importer process is running. Returns true on success.
-  bool ReloadPersistentPrefs();
-
-  // Returns true if the preference for the given preference name is available
-  // and is managed.
-  bool IsManagedPreference(const wchar_t* pref_name) const;
-
-  // Writes the data to disk. The return value only reflects whether
-  // serialization was successful; we don't know whether the data actually made
-  // it on disk (since it's on a different thread).  This should only be used if
-  // we need to save immediately (basically, during shutdown).  Otherwise, you
-  // should use ScheduleSavePersistentPrefs.
-  bool SavePersistentPrefs();
-
-  // Serializes the data and schedules save using ImportantFileWriter.
-  void ScheduleSavePersistentPrefs();
-
-  // Make the PrefService aware of a pref.
-  void RegisterBooleanPref(const wchar_t* path,
-                           bool default_value);
-  void RegisterIntegerPref(const wchar_t* path,
-                           int default_value);
-  void RegisterRealPref(const wchar_t* path,
-                        double default_value);
-  void RegisterStringPref(const wchar_t* path,
-                          const std::string& default_value);
-  void RegisterFilePathPref(const wchar_t* path,
-                            const FilePath& default_value);
-  void RegisterListPref(const wchar_t* path);
-  void RegisterDictionaryPref(const wchar_t* path);
-
-  // These varients use a default value from the locale dll instead.
-  void RegisterLocalizedBooleanPref(const wchar_t* path,
-                                    int locale_default_message_id);
-  void RegisterLocalizedIntegerPref(const wchar_t* path,
-                                    int locale_default_message_id);
-  void RegisterLocalizedRealPref(const wchar_t* path,
-                                 int locale_default_message_id);
-  void RegisterLocalizedStringPref(const wchar_t* path,
-                                   int locale_default_message_id);
-
-  // If the path is valid and the value at the end of the path matches the type
-  // specified, it will return the specified value.  Otherwise, the default
-  // value (set when the pref was registered) will be returned.
-  bool GetBoolean(const wchar_t* path) const;
-  int GetInteger(const wchar_t* path) const;
-  double GetReal(const wchar_t* path) const;
-  std::string GetString(const wchar_t* path) const;
-  FilePath GetFilePath(const wchar_t* path) const;
-
-  // Returns the branch if it exists.  If it's not a branch or the branch does
-  // not exist, returns NULL.
-  const DictionaryValue* GetDictionary(const wchar_t* path) const;
-  const ListValue* GetList(const wchar_t* path) const;
-
-  // If the pref at the given path changes, we call the observer's Observe
-  // method with NOTIFY_PREF_CHANGED.
-  virtual void AddPrefObserver(const wchar_t* path, NotificationObserver* obs);
-  void RemovePrefObserver(const wchar_t* path, NotificationObserver* obs);
-
-  // Removes a user pref and restores the pref to its default value.
-  void ClearPref(const wchar_t* path);
-
-  // If the path is valid (i.e., registered), update the pref value.
-  void Set(const wchar_t* path, const Value& value);
-  void SetBoolean(const wchar_t* path, bool value);
-  void SetInteger(const wchar_t* path, int value);
-  void SetReal(const wchar_t* path, double value);
-  void SetString(const wchar_t* path, const std::string& value);
-  void SetFilePath(const wchar_t* path, const FilePath& value);
-
-  // Int64 helper methods that actually store the given value as a string.
-  // Note that if obtaining the named value via GetDictionary or GetList, the
-  // Value type will be TYPE_STRING.
-  void SetInt64(const wchar_t* path, int64 value);
-  int64 GetInt64(const wchar_t* path) const;
-  void RegisterInt64Pref(const wchar_t* path, int64 default_value);
-
-  // Used to set the value of dictionary or list values in the pref tree.  This
-  // will create a dictionary or list if one does not exist in the pref tree.
-  // This method returns NULL only if you're requesting an unregistered pref or
-  // a non-dict/non-list pref.
-  // WARNING: Changes to the dictionary or list will not automatically notify
-  // pref observers.
-  // Use a ScopedPrefUpdate to update observers on changes.
-  DictionaryValue* GetMutableDictionary(const wchar_t* path);
-  ListValue* GetMutableList(const wchar_t* path);
-
-  // Returns true if a value has been set for the specified path.
-  // NOTE: this is NOT the same as FindPreference. In particular
-  // FindPreference returns whether RegisterXXX has been invoked, where as
-  // this checks if a value exists for the path.
-  bool HasPrefPath(const wchar_t* path) const;
-
-  class PreferencePathComparator {
-   public:
-    bool operator() (Preference* lhs, Preference* rhs) const {
-      return lhs->name() < rhs->name();
-    }
-  };
-  typedef std::set<Preference*, PreferencePathComparator> PreferenceSet;
-  const PreferenceSet& preference_set() const { return prefs_; }
-
-  // A helper method to quickly look up a preference.  Returns NULL if the
-  // preference is not registered.
-  const Preference* FindPreference(const wchar_t* pref_name) const;
-
-  // For the given pref_name, fire any observer of the pref only if |old_value|
-  // is different from the current value.  Virtual so it can be mocked for a
-  // unit test.
-  virtual void FireObserversIfChanged(const wchar_t* pref_name,
-                                      const Value* old_value);
-
-  bool read_only() const { return pref_value_store_->ReadOnly(); }
-
- protected:
-  // For the given pref_name, fire any observer of the pref.
-  void FireObservers(const wchar_t* pref_name);
-
-  // This should only be accessed by subclasses for unit-testing.
-  bool PrefIsChanged(const wchar_t* path, const Value* old_value);
-
- private:
-  // Add a preference to the PreferenceMap.  If the pref already exists, return
-  // false.  This method takes ownership of |pref|.
-  void RegisterPreference(Preference* pref);
-
-  // Returns a copy of the current pref value.  The caller is responsible for
-  // deleting the returned object.
-  Value* GetPrefCopy(const wchar_t* pref_name);
-
-  // Load from disk.  Returns a non-zero error code on failure.
-  PrefStore::PrefReadError LoadPersistentPrefs();
-
-  // Load preferences from storage, attempting to diagnose and handle errors.
-  // This should only be called from the constructor.
-  void InitFromStorage();
-
-  // The value of a Preference can be:
-  // managed, user defined, recommended or default.
-  // The PrefValueStore manages enforced, user defined and recommended values
-  // for Preferences. It returns the value of a Preference with the
-  // highest priority, and allows to set user defined values for preferences
-  // that are not managed.
-  scoped_ptr<PrefValueStore> pref_value_store_;
-
-  // A set of all the registered Preference objects.
-  PreferenceSet prefs_;
-
-  // A map from pref names to a list of observers.  Observers get fired in the
-  // order they are added.
-  typedef ObserverList<NotificationObserver> NotificationObserverList;
-  typedef base::hash_map<std::wstring, NotificationObserverList*>
-      PrefObserverMap;
-  PrefObserverMap pref_observers_;
-
-  friend class ScopedPrefUpdate;
-
-  DISALLOW_COPY_AND_ASSIGN(PrefService);
-};
-
-#endif  // CHROME_BROWSER_PREF_SERVICE_H_
diff --git a/chrome/browser/prefs/pref_service.cc b/chrome/browser/prefs/pref_service.cc
index 0668ed4..faa91ba 100644
--- a/chrome/browser/prefs/pref_service.cc
+++ b/chrome/browser/prefs/pref_service.cc
@@ -7,8 +7,13 @@
 #include <algorithm>
 #include <string>
 
+#ifndef ANDROID
+// FIXME: Do we need this on Android?
 #include "app/l10n_util.h"
+#endif
+#ifndef ANDROID
 #include "base/command_line.h"
+#endif
 #include "base/file_path.h"
 #include "base/file_util.h"
 #include "base/histogram.h"
@@ -22,9 +27,13 @@
 #include "build/build_config.h"
 #include "chrome/browser/chrome_thread.h"
 #include "chrome/browser/profile.h"
+#ifndef ANDROID
+// Notifications do not compile on Android and are the cause
+// of most of the ANDROID guards in this file.
 #include "chrome/common/notification_service.h"
 #include "grit/chromium_strings.h"
 #include "grit/generated_resources.h"
+#endif
 
 namespace {
 
@@ -32,6 +41,7 @@ namespace {
 // 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) {
+#ifndef ANDROID
   std::string resource_string = l10n_util::GetStringUTF8(message_id);
   DCHECK(!resource_string.empty());
   switch (type) {
@@ -64,6 +74,7 @@ Value* CreateLocaleDefaultValue(Value::ValueType type, int message_id) {
           "list and dictionary types cannot have default locale values";
     }
   }
+#endif
   NOTREACHED();
   return Value::CreateNullValue();
 }
@@ -71,9 +82,11 @@ Value* CreateLocaleDefaultValue(Value::ValueType type, int message_id) {
 // Forwards a notification after a PostMessage so that we can wait for the
 // MessageLoop to run.
 void NotifyReadError(PrefService* pref, int message_id) {
+#ifndef ANDROID
   Source<PrefService> source(pref);
   NotificationService::current()->Notify(NotificationType::PROFILE_ERROR,
                                          source, Details<int>(&message_id));
+#endif
 }
 
 }  // namespace
@@ -81,7 +94,7 @@ void NotifyReadError(PrefService* pref, int message_id) {
 // static
 PrefService* PrefService::CreatePrefService(const FilePath& pref_filename,
                                             Profile* profile) {
-#if defined(OS_LINUX)
+#if defined(OS_LINUX) && !defined(ANDROID)
   // We'd like to see what fraction of our users have the preferences
   // stored on a network file system, as we've had no end of troubles
   // with NFS/AFS.
@@ -106,7 +119,9 @@ PrefService* PrefService::CreateUserPrefService(const FilePath& pref_filename) {
 
 PrefService::PrefService(PrefValueStore* pref_value_store)
     : pref_value_store_(pref_value_store) {
+#ifndef ANDROID
   pref_notifier_.reset(new PrefNotifier(this, pref_value_store));
+#endif
   InitFromStorage();
 }
 
@@ -117,6 +132,7 @@ PrefService::~PrefService() {
 }
 
 void PrefService::InitFromStorage() {
+#ifndef ANDROID
   PrefStore::PrefReadError error = LoadPersistentPrefs();
   if (error == PrefStore::PREF_READ_ERROR_NONE)
     return;
@@ -136,6 +152,7 @@ void PrefService::InitFromStorage() {
         NewRunnableFunction(&NotifyReadError, this, message_id));
   }
   UMA_HISTOGRAM_ENUMERATION("PrefService.ReadError", error, 20);
+#endif
 }
 
 bool PrefService::ReloadPersistentPrefs() {
@@ -353,6 +370,7 @@ const ListValue* PrefService::GetList(const char* path) const {
   return static_cast<const ListValue*>(value);
 }
 
+#ifndef ANDROID
 void PrefService::AddPrefObserver(const char* path,
                                   NotificationObserver* obs) {
   pref_notifier_->AddPrefObserver(path, obs);
@@ -362,6 +380,7 @@ void PrefService::RemovePrefObserver(const char* path,
                                      NotificationObserver* obs) {
   pref_notifier_->RemovePrefObserver(path, obs);
 }
+#endif
 
 void PrefService::RegisterPreference(const char* path, Value* default_value) {
   DCHECK(CalledOnValidThread());
@@ -400,8 +419,10 @@ void PrefService::ClearPref(const char* path) {
     NOTREACHED() << "Trying to clear an unregistered pref: " << path;
     return;
   }
+#ifndef ANDROID
   if (pref_value_store_->RemoveUserPrefValue(path))
     pref_notifier_->OnUserPreferenceSet(path);
+#endif
 }
 
 void PrefService::Set(const char* path, const Value& value) {
@@ -427,9 +448,10 @@ void PrefService::Set(const char* path, const Value& value) {
   } else {
     value_changed = pref_value_store_->SetUserPrefValue(path, value.DeepCopy());
   }
-
+#ifndef ANDROID
   if (value_changed)
     pref_notifier_->OnUserPreferenceSet(path);
+#endif
 }
 
 void PrefService::SetBoolean(const char* path, bool value) {
@@ -564,8 +586,10 @@ void PrefService::SetUserPrefValue(const char* path, Value* new_value) {
     return;
   }
 
+#ifndef ANDROID
   if (pref_value_store_->SetUserPrefValue(path, new_value))
     pref_notifier_->OnUserPreferenceSet(path);
+#endif
 }
 
 ///////////////////////////////////////////////////////////////////////////////
diff --git a/chrome/browser/prefs/pref_service.h b/chrome/browser/prefs/pref_service.h
index 3e90db6..ddf551d 100644
--- a/chrome/browser/prefs/pref_service.h
+++ b/chrome/browser/prefs/pref_service.h
@@ -218,15 +218,19 @@ class PrefService : public NonThreadSafe {
 
   bool read_only() const { return pref_value_store_->ReadOnly(); }
 
+#ifndef ANDROID
   PrefNotifier* pref_notifier() const { return pref_notifier_.get(); }
+#endif
 
   PrefValueStore* pref_value_store() const { return pref_value_store_.get(); }
 
+#ifndef ANDROID
  protected:
   // The PrefNotifier handles registering and notifying preference observers.
   // It is created and owned by this PrefService. Subclasses may access it for
   // unit testing.
   scoped_ptr<PrefNotifier> pref_notifier_;
+#endif
 
  private:
   // Registration of pref change observers must be done using the
@@ -238,12 +242,14 @@ class PrefService : public NonThreadSafe {
   friend class PrefChangeRegistrar;
   friend class subtle::PrefMemberBase;
 
+#ifndef ANDROID
   // If the pref at the given path changes, we call the observer's Observe
   // method with PREF_CHANGED. Note that observers should not call these methods
   // directly but rather use a PrefChangeRegistrar to make sure the observer
   // gets cleaned up properly.
   virtual void AddPrefObserver(const char* path, NotificationObserver* obs);
   virtual void RemovePrefObserver(const char* path, NotificationObserver* obs);
+#endif
 
   // Add a preference to the PreferenceMap.  If the pref already exists, return
   // false.  This method takes ownership of |default_value|.
diff --git a/chrome/browser/prefs/pref_value_store.cc b/chrome/browser/prefs/pref_value_store.cc
index 46c825d..301270d 100644
--- a/chrome/browser/prefs/pref_value_store.cc
+++ b/chrome/browser/prefs/pref_value_store.cc
@@ -4,13 +4,17 @@
 
 #include "chrome/browser/prefs/pref_value_store.h"
 
+#ifndef ANDROID
 #include "chrome/browser/chrome_thread.h"
 #include "chrome/browser/extensions/extension_pref_store.h"
 #include "chrome/browser/policy/configuration_policy_pref_store.h"
 #include "chrome/browser/prefs/command_line_pref_store.h"
+#endif
 #include "chrome/browser/prefs/default_pref_store.h"
+#ifndef ANDROID
 #include "chrome/common/json_pref_store.h"
 #include "chrome/common/notification_service.h"
+#endif
 
 namespace {
 
@@ -38,6 +42,9 @@ PrefValueStore* PrefValueStore::CreatePrefValueStore(
     const FilePath& pref_filename,
     Profile* profile,
     bool user_only) {
+#ifdef ANDROID
+  return new PrefValueStore(NULL, NULL, NULL, NULL, NULL, new DefaultPrefStore());
+#else
   using policy::ConfigurationPolicyPrefStore;
   ConfigurationPolicyPrefStore* managed = NULL;
   ExtensionPrefStore* extension = NULL;
@@ -58,6 +65,7 @@ PrefValueStore* PrefValueStore::CreatePrefValueStore(
   }
   return new PrefValueStore(managed, extension, command_line, user,
                             recommended, default_store);
+#endif
 }
 
 PrefValueStore::~PrefValueStore() {}
@@ -239,6 +247,7 @@ bool PrefValueStore::PrefValueInStore(const char* name,
   return false;
 }
 
+#ifndef ANDROID
 void PrefValueStore::RefreshPolicyPrefsCompletion(
     PrefStore* new_managed_pref_store,
     PrefStore* new_recommended_pref_store,
@@ -323,6 +332,7 @@ void PrefValueStore::RefreshPolicyPrefs(
                         new_recommended_pref_store,
                         callback));
 }
+#endif // ANDROID
 
 PrefValueStore::PrefValueStore(PrefStore* managed_prefs,
                                PrefStore* extension_prefs,
diff --git a/chrome/browser/prefs/pref_value_store.h b/chrome/browser/prefs/pref_value_store.h
index c361e07..bd1bc6d 100644
--- a/chrome/browser/prefs/pref_value_store.h
+++ b/chrome/browser/prefs/pref_value_store.h
@@ -16,7 +16,9 @@
 #include "base/ref_counted.h"
 #include "base/scoped_ptr.h"
 #include "base/values.h"
+#ifndef ANDROID
 #include "chrome/browser/chrome_thread.h"
+#endif
 #include "chrome/browser/prefs/pref_notifier.h"
 #include "chrome/common/pref_store.h"
 
@@ -47,6 +49,9 @@ class PrefValueStore : public base::RefCountedThreadSafe<PrefValueStore> {
                                               Profile* profile,
                                               bool user_only);
 
+#ifdef ANDROID
+  virtual
+#endif
   ~PrefValueStore();
 
   // Gets the value for the given preference name that has a valid value type;
@@ -147,6 +152,7 @@ class PrefValueStore : public base::RefCountedThreadSafe<PrefValueStore> {
   // lifecycle is managed in another thread.
   typedef Callback1<std::vector<std::string> >::Type AfterRefreshCallback;
 
+#ifndef ANDROID
   // Called as a result of a notification of policy change. Triggers a
   // reload of managed preferences from policy. Caller must pass in
   // new, uninitialized managed and recommended PrefStores in
@@ -159,6 +165,7 @@ class PrefValueStore : public base::RefCountedThreadSafe<PrefValueStore> {
   void RefreshPolicyPrefs(PrefStore* managed_pref_store,
                           PrefStore* recommended_pref_store,
                           AfterRefreshCallback* callback);
+#endif
 
  protected:
   // In decreasing order of precedence:
@@ -198,6 +205,7 @@ class PrefValueStore : public base::RefCountedThreadSafe<PrefValueStore> {
   bool PrefValueInStore(const char* name,
                         PrefNotifier::PrefStoreType store) const;
 
+#ifndef ANDROID
   // Called during policy refresh after ReadPrefs completes on the thread
   // that initiated the policy refresh. RefreshPolicyPrefsCompletion takes
   // ownership of the |callback| object.
@@ -213,6 +221,7 @@ class PrefValueStore : public base::RefCountedThreadSafe<PrefValueStore> {
       PrefStore* new_managed_pref_store,
       PrefStore* new_recommended_pref_store,
       AfterRefreshCallback* callback);
+#endif
 
   DISALLOW_COPY_AND_ASSIGN(PrefValueStore);
 };