chrome/browser/android/preferences/pref_service_bridge.cc

   1 // Copyright 2014 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "chrome/browser/android/preferences/pref_service_bridge.h"
   6
   7 #include <jni.h>
   8
   9 #include "base/android/build_info.h"
  10 #include "base/android/jni_android.h"
  11 #include "base/android/jni_string.h"
  12 #include "base/android/jni_weak_ref.h"
  13 #include "base/files/file_path.h"
  14 #include "base/files/file_util.h"
  15 #include "base/memory/scoped_ptr.h"
  16 #include "base/prefs/pref_service.h"
  17 #include "base/strings/string_util.h"
  18 #include "base/values.h"
  19 #include "chrome/browser/browser_process.h"
  20 #include "chrome/browser/browsing_data/browsing_data_helper.h"
  21 #include "chrome/browser/browsing_data/browsing_data_remover.h"
  22 #include "chrome/browser/net/prediction_options.h"
  23 #include "chrome/browser/prefs/incognito_mode_prefs.h"
  24 #include "chrome/browser/profiles/profile_manager.h"
  25 #include "chrome/browser/translate/chrome_translate_client.h"
  26 #include "chrome/browser/ui/android/android_about_app_info.h"
  27 #include "chrome/common/chrome_version_info.h"
  28 #include "chrome/common/pref_names.h"
  29 #include "chrome/grit/locale_settings.h"
  30 #include "components/content_settings/core/browser/host_content_settings_map.h"
  31 #include "components/content_settings/core/common/content_settings.h"
  32 #include "components/content_settings/core/common/content_settings_pattern.h"
  33 #include "components/password_manager/core/common/password_manager_pref_names.h"
  34 #include "components/translate/core/browser/translate_prefs.h"
  35 #include "components/translate/core/common/translate_pref_names.h"
  36 #include "content/public/browser/browser_thread.h"
  37 #include "content/public/common/user_agent.h"
  38 #include "jni/PrefServiceBridge_jni.h"
  39 #include "ui/base/l10n/l10n_util.h"
  40
  41 using base::android::AttachCurrentThread;
  42 using base::android::CheckException;
  43 using base::android::ConvertJavaStringToUTF8;
  44 using base::android::ConvertUTF8ToJavaString;
  45 using base::android::ScopedJavaLocalRef;
  46 using base::android::ScopedJavaGlobalRef;
  47 using content::BrowserThread;
  48
  49 namespace {
  50
  51 enum NetworkPredictionOptions {
  52   NETWORK_PREDICTION_ALWAYS,
  53   NETWORK_PREDICTION_WIFI_ONLY,
  54   NETWORK_PREDICTION_NEVER,
  55 };
  56
  57 Profile* GetOriginalProfile() {
  58   return ProfileManager::GetActiveUserProfile()->GetOriginalProfile();
  59 }
  60
  61 bool GetBooleanForContentSetting(HostContentSettingsMap* content_settings,
  62                                  ContentSettingsType type) {
  63   switch (content_settings->GetDefaultContentSetting(type, NULL)) {
  64     case CONTENT_SETTING_BLOCK:
  65       return false;
  66     case CONTENT_SETTING_ALLOW:
  67       return true;
  68     case CONTENT_SETTING_ASK:
  69     default:
  70       return true;
  71   }
  72 }
  73
  74 std::string GetStringForContentSettingsType(
  75     ContentSetting content_setting) {
  76   switch (content_setting) {
  77     case CONTENT_SETTING_BLOCK:
  78       return "block";
  79     case CONTENT_SETTING_ALLOW:
  80       return "allow";
  81     case CONTENT_SETTING_ASK:
  82       return "ask";
  83     case CONTENT_SETTING_SESSION_ONLY:
  84       return "session";
  85     case CONTENT_SETTING_NUM_SETTINGS:
  86       return "num_settings";
  87     case CONTENT_SETTING_DEFAULT:
  88     default:
  89       return "default";
  90   }
  91 }
  92
  93 bool IsContentSettingManaged(HostContentSettingsMap* content_settings,
  94                              ContentSettingsType content_settings_type) {
  95   std::string source;
  96   content_settings->GetDefaultContentSetting(content_settings_type, &source);
  97   HostContentSettingsMap::ProviderType provider =
  98       content_settings->GetProviderTypeFromSource(source);
  99   return provider == HostContentSettingsMap::POLICY_PROVIDER;
 100 }
 101
 102 void OnGotProfilePath(ScopedJavaGlobalRef<jobject>* callback,
 103                       std::string path) {
 104   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 105   JNIEnv* env = AttachCurrentThread();
 106   ScopedJavaLocalRef<jstring> j_path = ConvertUTF8ToJavaString(env, path);
 107   Java_PrefServiceBridge_onGotProfilePath(env, j_path.obj(), callback->obj());
 108 }
 109
 110 std::string GetProfilePathOnFileThread(Profile* profile) {
 111   DCHECK_CURRENTLY_ON(BrowserThread::FILE);
 112   if (!profile)
 113     return std::string();
 114
 115   base::FilePath profile_path = profile->GetPath();
 116   return base::MakeAbsoluteFilePath(profile_path).value();
 117 }
 118
 119 PrefService* GetPrefService() {
 120   return GetOriginalProfile()->GetPrefs();
 121 }
 122
 123 static void EnsureConsistentGeolocationPreferences(Profile* profile) {
 124   // On Android, we use the kGeolocationEnabled flag to control geolocation on a
 125   // global basis, rather than the default geolocation host content setting,
 126   // which is only used if no previously stored more specific host exception
 127   // cannot be found.
 128   //
 129   // On Android, there is currently no UI to change this default setting, so it
 130   // needs to default to ASK. Additionally, for users that have previously set
 131   // the default to BLOCK, we set the preference to disable geolocation
 132   // globally.
 133
 134   ContentSetting defaultSetting = profile->GetHostContentSettingsMap()->
 135       GetDefaultContentSetting(CONTENT_SETTINGS_TYPE_GEOLOCATION, NULL);
 136
 137   if (defaultSetting == CONTENT_SETTING_ASK)
 138     return;
 139
 140   profile->GetHostContentSettingsMap()->SetDefaultContentSetting(
 141       CONTENT_SETTINGS_TYPE_GEOLOCATION, CONTENT_SETTING_ASK);
 142
 143   if (defaultSetting == CONTENT_SETTING_BLOCK) {
 144     profile->GetPrefs()->SetBoolean(prefs::kGeolocationEnabled, false);
 145   }
 146 }
 147
 148 static void EnsureConsistentProtectedMediaIdentifierPreferences(
 149     Profile* profile) {
 150   // We use the kProtectedMediaIdentifierEnabled flag to control protected media
 151   // identifier on a global basis.
 152   //
 153   // On Android, there is currently no UI to change this default setting, so it
 154   // needs to default to ASK. Additionally, for users that have previously set
 155   // the default to BLOCK, we set the preference to disable protected media
 156   // identifier globally.
 157   ContentSetting defaultSetting =
 158       profile->GetHostContentSettingsMap()->
 159       GetDefaultContentSetting(CONTENT_SETTINGS_TYPE_PROTECTED_MEDIA_IDENTIFIER,
 160                                NULL);
 161
 162   if (defaultSetting == CONTENT_SETTING_ASK)
 163     return;
 164
 165   profile->GetHostContentSettingsMap()->SetDefaultContentSetting(
 166       CONTENT_SETTINGS_TYPE_PROTECTED_MEDIA_IDENTIFIER, CONTENT_SETTING_ASK);
 167
 168   if (defaultSetting == CONTENT_SETTING_BLOCK) {
 169     profile->GetPrefs()->SetBoolean(prefs::kProtectedMediaIdentifierEnabled,
 170                                     false);
 171   }
 172 }
 173
 174 }  // namespace
 175
 176 // ----------------------------------------------------------------------------
 177 // Native JNI methods
 178 // ----------------------------------------------------------------------------
 179
 180 static jboolean GetAcceptCookiesEnabled(JNIEnv* env, jobject obj) {
 181   return GetBooleanForContentSetting(
 182       GetOriginalProfile()->GetHostContentSettingsMap(),
 183       CONTENT_SETTINGS_TYPE_COOKIES);
 184 }
 185
 186 static jboolean GetAcceptCookiesManaged(JNIEnv* env, jobject obj) {
 187   return IsContentSettingManaged(
 188       GetOriginalProfile()->GetHostContentSettingsMap(),
 189       CONTENT_SETTINGS_TYPE_COOKIES);
 190 }
 191
 192 static jboolean GetBlockThirdPartyCookiesEnabled(JNIEnv* env, jobject obj) {
 193   return GetPrefService()->GetBoolean(prefs::kBlockThirdPartyCookies);
 194 }
 195
 196 static jboolean GetBlockThirdPartyCookiesManaged(JNIEnv* env, jobject obj) {
 197   return GetPrefService()->IsManagedPreference(prefs::kBlockThirdPartyCookies);
 198 }
 199
 200 static jboolean GetRememberPasswordsEnabled(JNIEnv* env, jobject obj) {
 201   return GetPrefService()->GetBoolean(
 202       password_manager::prefs::kPasswordManagerSavingEnabled);
 203 }
 204
 205 static jboolean GetRememberPasswordsManaged(JNIEnv* env, jobject obj) {
 206   return GetPrefService()->IsManagedPreference(
 207       password_manager::prefs::kPasswordManagerSavingEnabled);
 208 }
 209
 210 static jboolean GetDoNotTrackEnabled(JNIEnv* env, jobject obj) {
 211   return GetPrefService()->GetBoolean(prefs::kEnableDoNotTrack);
 212 }
 213
 214 static jint GetNetworkPredictionOptions(JNIEnv* env, jobject obj) {
 215   return GetPrefService()->GetInteger(prefs::kNetworkPredictionOptions);
 216 }
 217
 218 static jboolean GetNetworkPredictionManaged(JNIEnv* env, jobject obj) {
 219   return GetPrefService()->IsManagedPreference(
 220       prefs::kNetworkPredictionOptions);
 221 }
 222
 223 static jboolean GetPasswordEchoEnabled(JNIEnv* env, jobject obj) {
 224   return GetPrefService()->GetBoolean(prefs::kWebKitPasswordEchoEnabled);
 225 }
 226
 227 static jboolean GetPrintingEnabled(JNIEnv* env, jobject obj) {
 228   return GetPrefService()->GetBoolean(prefs::kPrintingEnabled);
 229 }
 230
 231 static jboolean GetPrintingManaged(JNIEnv* env, jobject obj) {
 232   return GetPrefService()->IsManagedPreference(prefs::kPrintingEnabled);
 233 }
 234
 235 static jboolean GetTranslateEnabled(JNIEnv* env, jobject obj) {
 236   return GetPrefService()->GetBoolean(prefs::kEnableTranslate);
 237 }
 238
 239 static jboolean GetTranslateManaged(JNIEnv* env, jobject obj) {
 240   return GetPrefService()->IsManagedPreference(prefs::kEnableTranslate);
 241 }
 242
 243 static jboolean GetSearchSuggestEnabled(JNIEnv* env, jobject obj) {
 244   return GetPrefService()->GetBoolean(prefs::kSearchSuggestEnabled);
 245 }
 246
 247 static jboolean GetSearchSuggestManaged(JNIEnv* env, jobject obj) {
 248   return GetPrefService()->IsManagedPreference(prefs::kSearchSuggestEnabled);
 249 }
 250
 251 static jboolean GetProtectedMediaIdentifierEnabled(JNIEnv* env, jobject obj) {
 252   Profile* profile = GetOriginalProfile();
 253   EnsureConsistentProtectedMediaIdentifierPreferences(profile);
 254   return GetPrefService()->GetBoolean(prefs::kProtectedMediaIdentifierEnabled);
 255 }
 256
 257 static jboolean GetAllowLocationEnabled(JNIEnv* env, jobject obj) {
 258   Profile* profile = GetOriginalProfile();
 259   EnsureConsistentGeolocationPreferences(profile);
 260   return GetPrefService()->GetBoolean(prefs::kGeolocationEnabled);
 261 }
 262
 263 static jboolean GetAllowLocationManaged(JNIEnv* env, jobject obj) {
 264   return IsContentSettingManaged(
 265       GetOriginalProfile()->GetHostContentSettingsMap(),
 266       CONTENT_SETTINGS_TYPE_GEOLOCATION);
 267 }
 268
 269 static jboolean GetResolveNavigationErrorEnabled(JNIEnv* env, jobject obj) {
 270   return GetPrefService()->GetBoolean(prefs::kAlternateErrorPagesEnabled);
 271 }
 272
 273 static jboolean GetResolveNavigationErrorManaged(JNIEnv* env, jobject obj) {
 274   return GetPrefService()->IsManagedPreference(
 275       prefs::kAlternateErrorPagesEnabled);
 276 }
 277
 278 static jboolean GetCrashReportManaged(JNIEnv* env, jobject obj) {
 279   return GetPrefService()->IsManagedPreference(
 280       prefs::kCrashReportingEnabled);
 281 }
 282
 283 static jboolean GetForceSafeSearch(JNIEnv* env, jobject obj) {
 284   return GetPrefService()->GetBoolean(prefs::kForceSafeSearch);
 285 }
 286
 287 static jint GetDefaultSupervisedUserFilteringBehavior(JNIEnv* env,
 288                                                       jobject obj) {
 289   return GetPrefService()->GetInteger(
 290       prefs::kDefaultSupervisedUserFilteringBehavior);
 291 }
 292
 293 static jboolean GetIncognitoModeEnabled(JNIEnv* env, jobject obj) {
 294   PrefService* prefs = GetPrefService();
 295   IncognitoModePrefs::Availability incognito_pref =
 296       IncognitoModePrefs::GetAvailability(prefs);
 297   DCHECK(incognito_pref == IncognitoModePrefs::ENABLED ||
 298          incognito_pref == IncognitoModePrefs::DISABLED) <<
 299              "Unsupported incognito mode preference: " << incognito_pref;
 300   return incognito_pref != IncognitoModePrefs::DISABLED;
 301 }
 302
 303 static jboolean GetIncognitoModeManaged(JNIEnv* env, jobject obj) {
 304   return GetPrefService()->IsManagedPreference(
 305       prefs::kIncognitoModeAvailability);
 306 }
 307
 308 namespace {
 309
 310 // Redirects a BrowsingDataRemover completion callback back into Java.
 311 class ClearBrowsingDataObserver : public BrowsingDataRemover::Observer {
 312  public:
 313   // |obj| is expected to be the object passed into ClearBrowsingData(); e.g. a
 314   // ChromePreference.
 315   ClearBrowsingDataObserver(JNIEnv* env, jobject obj)
 316       : weak_chrome_native_preferences_(env, obj) {
 317   }
 318
 319   virtual void OnBrowsingDataRemoverDone() override {
 320     // Just as a BrowsingDataRemover deletes itself when done, we delete ourself
 321     // when done.  No need to remove ourself as an observer given the lifetime
 322     // of BrowsingDataRemover.
 323     scoped_ptr<ClearBrowsingDataObserver> auto_delete(this);
 324
 325     JNIEnv* env = AttachCurrentThread();
 326     if (weak_chrome_native_preferences_.get(env).is_null())
 327       return;
 328
 329     Java_PrefServiceBridge_browsingDataCleared(
 330         env, weak_chrome_native_preferences_.get(env).obj());
 331   }
 332
 333  private:
 334   JavaObjectWeakGlobalRef weak_chrome_native_preferences_;
 335 };
 336 }  // namespace
 337
 338 static void ClearBrowsingData(JNIEnv* env, jobject obj, jboolean history,
 339     jboolean cache, jboolean cookies_and_site_data, jboolean passwords,
 340     jboolean form_data) {
 341   // BrowsingDataRemover deletes itself.
 342   BrowsingDataRemover* browsing_data_remover =
 343       BrowsingDataRemover::CreateForPeriod(
 344           GetOriginalProfile(),
 345           static_cast<BrowsingDataRemover::TimePeriod>(
 346               BrowsingDataRemover::EVERYTHING));
 347   browsing_data_remover->AddObserver(new ClearBrowsingDataObserver(env, obj));
 348
 349   int remove_mask = 0;
 350   if (history)
 351     remove_mask |= BrowsingDataRemover::REMOVE_HISTORY;
 352   if (cache)
 353     remove_mask |= BrowsingDataRemover::REMOVE_CACHE;
 354   if (cookies_and_site_data) {
 355     remove_mask |= BrowsingDataRemover::REMOVE_COOKIES;
 356     remove_mask |= BrowsingDataRemover::REMOVE_SITE_DATA;
 357   }
 358   if (passwords)
 359     remove_mask |= BrowsingDataRemover::REMOVE_PASSWORDS;
 360   if (form_data)
 361     remove_mask |= BrowsingDataRemover::REMOVE_FORM_DATA;
 362   browsing_data_remover->Remove(remove_mask,
 363                                 BrowsingDataHelper::UNPROTECTED_WEB);
 364 }
 365
 366 static void SetAllowCookiesEnabled(JNIEnv* env, jobject obj, jboolean allow) {
 367   HostContentSettingsMap* host_content_settings_map =
 368       GetOriginalProfile()->GetHostContentSettingsMap();
 369   host_content_settings_map->SetDefaultContentSetting(
 370       CONTENT_SETTINGS_TYPE_COOKIES,
 371       allow ? CONTENT_SETTING_ALLOW : CONTENT_SETTING_BLOCK);
 372 }
 373
 374 static void SetBlockThirdPartyCookiesEnabled(JNIEnv* env, jobject obj,
 375                                              jboolean enabled) {
 376   GetPrefService()->SetBoolean(prefs::kBlockThirdPartyCookies, enabled);
 377 }
 378
 379 static void SetRememberPasswordsEnabled(JNIEnv* env, jobject obj,
 380                                         jboolean allow) {
 381   GetPrefService()->SetBoolean(
 382       password_manager::prefs::kPasswordManagerSavingEnabled, allow);
 383 }
 384
 385 static void SetProtectedMediaIdentifierEnabled(JNIEnv* env,
 386                                                jobject obj,
 387                                                jboolean is_enabled) {
 388   GetPrefService()->SetBoolean(prefs::kProtectedMediaIdentifierEnabled,
 389                                is_enabled);
 390 }
 391
 392 static void SetAllowLocationEnabled(JNIEnv* env, jobject obj, jboolean allow) {
 393   GetPrefService()->SetBoolean(prefs::kGeolocationEnabled, allow);
 394 }
 395
 396 static void SetCrashReporting(JNIEnv* env, jobject obj, jboolean reporting) {
 397   PrefService* local_state = g_browser_process->local_state();
 398   local_state->SetBoolean(prefs::kCrashReportingEnabled, reporting);
 399 }
 400
 401 static jboolean CanPredictNetworkActions(JNIEnv* env, jobject obj) {
 402   return chrome_browser_net::CanPrefetchAndPrerenderUI(GetPrefService());
 403 }
 404
 405 static void SetDoNotTrackEnabled(JNIEnv* env, jobject obj, jboolean allow) {
 406   GetPrefService()->SetBoolean(prefs::kEnableDoNotTrack, allow);
 407 }
 408
 409 static jstring GetSyncLastAccountName(JNIEnv* env, jobject obj) {
 410   return ConvertUTF8ToJavaString(
 411       env, GetPrefService()->GetString(prefs::kGoogleServicesLastUsername))
 412       .Release();
 413 }
 414
 415 static void SetTranslateEnabled(JNIEnv* env, jobject obj, jboolean enabled) {
 416   GetPrefService()->SetBoolean(prefs::kEnableTranslate, enabled);
 417 }
 418
 419 static void ResetTranslateDefaults(JNIEnv* env, jobject obj) {
 420   scoped_ptr<translate::TranslatePrefs> translate_prefs =
 421       ChromeTranslateClient::CreateTranslatePrefs(GetPrefService());
 422   translate_prefs->ResetToDefaults();
 423 }
 424
 425 static jboolean GetJavaScriptManaged(JNIEnv* env, jobject obj) {
 426   HostContentSettingsMap* content_settings =
 427       GetOriginalProfile()->GetHostContentSettingsMap();
 428   return IsContentSettingManaged(
 429       content_settings, CONTENT_SETTINGS_TYPE_JAVASCRIPT);
 430 }
 431
 432 static void SetJavaScriptEnabled(JNIEnv* env, jobject obj, jboolean enabled) {
 433   GetPrefService()->SetBoolean(prefs::kWebKitJavascriptEnabled, enabled);
 434 }
 435
 436 static jboolean GetJavaScriptEnabled(JNIEnv* env, jobject obj) {
 437   // The user pref for Javascript is stored in kWebKitJavascriptEnabled for
 438   // historical reasons, but the content setting is where a possibly managed
 439   // value will be enforced.
 440   HostContentSettingsMap* content_settings =
 441       GetOriginalProfile()->GetHostContentSettingsMap();
 442
 443   jboolean javascript_enabled = GetBooleanForContentSetting(
 444       content_settings, CONTENT_SETTINGS_TYPE_JAVASCRIPT);
 445   if (!GetJavaScriptManaged(env, obj)) {
 446     javascript_enabled &= GetPrefService()->GetBoolean(
 447         prefs::kWebKitJavascriptEnabled);
 448   }
 449   return javascript_enabled;
 450 }
 451
 452 static void SetPasswordEchoEnabled(JNIEnv* env,
 453                                    jobject obj,
 454                                    jboolean passwordEchoEnabled) {
 455   GetPrefService()->SetBoolean(prefs::kWebKitPasswordEchoEnabled,
 456                                passwordEchoEnabled);
 457 }
 458
 459 static jboolean GetAllowPopupsEnabled(JNIEnv* env, jobject obj) {
 460   HostContentSettingsMap* content_settings =
 461       GetOriginalProfile()->GetHostContentSettingsMap();
 462   return GetBooleanForContentSetting(content_settings,
 463       CONTENT_SETTINGS_TYPE_POPUPS);
 464 }
 465
 466 static jboolean GetAllowPopupsManaged(JNIEnv* env, jobject obj) {
 467   HostContentSettingsMap* content_settings =
 468       GetOriginalProfile()->GetHostContentSettingsMap();
 469   return IsContentSettingManaged(content_settings,
 470                                  CONTENT_SETTINGS_TYPE_POPUPS);
 471 }
 472
 473 static void SetAllowPopupsEnabled(JNIEnv* env, jobject obj, jboolean allow) {
 474   HostContentSettingsMap* host_content_settings_map =
 475       GetOriginalProfile()->GetHostContentSettingsMap();
 476   host_content_settings_map->SetDefaultContentSetting(
 477       CONTENT_SETTINGS_TYPE_POPUPS,
 478       allow ? CONTENT_SETTING_ALLOW : CONTENT_SETTING_BLOCK);
 479 }
 480
 481 static jboolean GetCameraMicEnabled(JNIEnv* env, jobject obj) {
 482   HostContentSettingsMap* content_settings =
 483       GetOriginalProfile()->GetHostContentSettingsMap();
 484   return GetBooleanForContentSetting(content_settings,
 485       CONTENT_SETTINGS_TYPE_MEDIASTREAM);
 486 }
 487
 488 static jboolean GetAutologinEnabled(JNIEnv* env, jobject obj) {
 489   return GetPrefService()->GetBoolean(prefs::kAutologinEnabled);
 490 }
 491
 492 static void SetAutologinEnabled(JNIEnv* env, jobject obj,
 493                                 jboolean autologinEnabled) {
 494   GetPrefService()->SetBoolean(prefs::kAutologinEnabled, autologinEnabled);
 495 }
 496
 497 static void SetPopupException(JNIEnv* env, jobject obj, jstring pattern,
 498                               jboolean allow) {
 499   HostContentSettingsMap* host_content_settings_map =
 500       GetOriginalProfile()->GetHostContentSettingsMap();
 501   host_content_settings_map->SetContentSetting(
 502       ContentSettingsPattern::FromString(ConvertJavaStringToUTF8(env, pattern)),
 503       ContentSettingsPattern::Wildcard(),
 504       CONTENT_SETTINGS_TYPE_POPUPS,
 505       "",
 506       allow ? CONTENT_SETTING_ALLOW : CONTENT_SETTING_BLOCK);
 507 }
 508
 509 static void RemovePopupException(JNIEnv* env, jobject obj, jstring pattern) {
 510   HostContentSettingsMap* host_content_settings_map =
 511       GetOriginalProfile()->GetHostContentSettingsMap();
 512   host_content_settings_map->SetContentSetting(
 513       ContentSettingsPattern::FromString(ConvertJavaStringToUTF8(env, pattern)),
 514       ContentSettingsPattern::Wildcard(),
 515       CONTENT_SETTINGS_TYPE_POPUPS,
 516       "",
 517       CONTENT_SETTING_DEFAULT);
 518 }
 519
 520 static void GetPopupExceptions(JNIEnv* env, jobject obj, jobject list) {
 521   HostContentSettingsMap* host_content_settings_map =
 522       GetOriginalProfile()->GetHostContentSettingsMap();
 523   ContentSettingsForOneType entries;
 524   host_content_settings_map->GetSettingsForOneType(
 525       CONTENT_SETTINGS_TYPE_POPUPS, "", &entries);
 526   for (size_t i = 0; i < entries.size(); ++i) {
 527     Java_PrefServiceBridge_insertPopupExceptionToList(
 528         env, list,
 529         ConvertUTF8ToJavaString(
 530             env, entries[i].primary_pattern.ToString()).obj(),
 531         ConvertUTF8ToJavaString(
 532             env, GetStringForContentSettingsType(entries[i].setting)).obj(),
 533         ConvertUTF8ToJavaString(env, entries[i].source).obj());
 534   }
 535 }
 536
 537 static void SetSearchSuggestEnabled(JNIEnv* env, jobject obj,
 538                                     jboolean enabled) {
 539   GetPrefService()->SetBoolean(prefs::kSearchSuggestEnabled, enabled);
 540 }
 541
 542 static jstring GetContextualSearchPreference(JNIEnv* env, jobject obj) {
 543   return ConvertUTF8ToJavaString(
 544       env, GetPrefService()->GetString(prefs::kContextualSearchEnabled)).
 545           Release();
 546 }
 547
 548 static void SetContextualSearchPreference(JNIEnv* env, jobject obj,
 549                                           jstring pref) {
 550   GetPrefService()->SetString(prefs::kContextualSearchEnabled,
 551       ConvertJavaStringToUTF8(env, pref));
 552 }
 553
 554 static void SetNetworkPredictionOptions(JNIEnv* env, jobject obj, int option) {
 555   GetPrefService()->SetInteger(prefs::kNetworkPredictionOptions, option);
 556 }
 557
 558 static jboolean NetworkPredictionEnabledHasUserSetting(JNIEnv* env,
 559                                                        jobject obj) {
 560   return GetPrefService()->GetUserPrefValue(
 561       prefs::kNetworkPredictionEnabled) != NULL;
 562 }
 563
 564 static jboolean NetworkPredictionOptionsHasUserSetting(JNIEnv* env,
 565                                                        jobject obj) {
 566   return GetPrefService()->GetUserPrefValue(
 567       prefs::kNetworkPredictionOptions) != NULL;
 568 }
 569
 570 static jboolean GetNetworkPredictionEnabledUserPrefValue(JNIEnv* env,
 571                                                          jobject obj) {
 572   const base::Value* network_prediction_enabled =
 573       GetPrefService()->GetUserPrefValue(prefs::kNetworkPredictionEnabled);
 574   DCHECK(network_prediction_enabled);
 575   bool value = false;
 576   DCHECK(network_prediction_enabled->GetAsBoolean(&value));
 577   return value;
 578 }
 579
 580 static void SetResolveNavigationErrorEnabled(JNIEnv* env, jobject obj,
 581                                              jboolean enabled) {
 582   GetPrefService()->SetBoolean(prefs::kAlternateErrorPagesEnabled, enabled);
 583 }
 584
 585 static jboolean GetFirstRunEulaAccepted(JNIEnv* env, jobject obj) {
 586   return g_browser_process->local_state()->GetBoolean(prefs::kEulaAccepted);
 587 }
 588
 589 static void SetEulaAccepted(JNIEnv* env, jobject obj) {
 590   g_browser_process->local_state()->SetBoolean(prefs::kEulaAccepted, true);
 591 }
 592
 593 static void ResetAcceptLanguages(JNIEnv* env,
 594                                  jobject obj,
 595                                  jstring default_locale) {
 596   std::string accept_languages(l10n_util::GetStringUTF8(IDS_ACCEPT_LANGUAGES));
 597   std::string locale_string(ConvertJavaStringToUTF8(env, default_locale));
 598
 599   PrependToAcceptLanguagesIfNecessary(locale_string, &accept_languages);
 600   GetPrefService()->SetString(prefs::kAcceptLanguages, accept_languages);
 601 }
 602
 603 void PrependToAcceptLanguagesIfNecessary(std::string locale,
 604                                          std::string* accept_languages) {
 605   if (locale.size() != 5u || locale[2] != '_')  // not well-formed
 606     return;
 607
 608   std::string language(locale.substr(0, 2));
 609   std::string region(locale.substr(3, 2));
 610
 611   // Java mostly follows ISO-639-1 and ICU, except for the following three.
 612   // See documentation on java.util.Locale constructor for more.
 613   if (language == "iw") {
 614     language = "he";
 615   } else if (language == "ji") {
 616     language = "yi";
 617   } else if (language == "in") {
 618     language = "id";
 619   }
 620
 621   std::string language_region(language + "-" + region);
 622
 623   if (accept_languages->find(language_region) == std::string::npos) {
 624     std::vector<std::string> parts;
 625     parts.push_back(language_region);
 626     // If language is not in the accept languages list, also add language code.
 627     if (accept_languages->find(language + ",") == std::string::npos &&
 628         !std::equal(language.rbegin(), language.rend(),
 629                     accept_languages->rbegin()))
 630       parts.push_back(language);
 631     parts.push_back(*accept_languages);
 632     *accept_languages = JoinString(parts, ',');
 633   }
 634 }
 635
 636 // Sends all information about the different versions to Java.
 637 // From browser_about_handler.cc
 638 static jobject GetAboutVersionStrings(JNIEnv* env, jobject obj) {
 639   chrome::VersionInfo version_info;
 640   std::string os_version = version_info.OSType();
 641   os_version += " " + AndroidAboutAppInfo::GetOsInfo();
 642
 643   base::android::BuildInfo* android_build_info =
 644         base::android::BuildInfo::GetInstance();
 645   std::string application(android_build_info->package_label());
 646   application.append(" ");
 647   application.append(version_info.Version());
 648
 649   // OK to release, returning to Java.
 650   return Java_PrefServiceBridge_createAboutVersionStrings(
 651       env,
 652       ConvertUTF8ToJavaString(env, application).obj(),
 653       ConvertUTF8ToJavaString(env, content::GetWebKitVersion()).obj(),
 654       ConvertUTF8ToJavaString(
 655           env, AndroidAboutAppInfo::GetJavaScriptVersion()).obj(),
 656       ConvertUTF8ToJavaString(env, os_version).obj()).Release();
 657 }
 658
 659 static void GetProfilePath(JNIEnv* env, jobject obj, jobject j_callback) {
 660   ScopedJavaGlobalRef<jobject>* callback = new ScopedJavaGlobalRef<jobject>();
 661   callback->Reset(env, j_callback);
 662   BrowserThread::PostTaskAndReplyWithResult(
 663       BrowserThread::FILE, FROM_HERE,
 664       base::Bind(&GetProfilePathOnFileThread, GetOriginalProfile()),
 665       base::Bind(&OnGotProfilePath, base::Owned(callback)));
 666 }
 667
 668 static jstring GetSupervisedUserCustodianName(JNIEnv* env, jobject obj) {
 669   return ConvertUTF8ToJavaString(
 670       env, GetPrefService()->GetString(prefs::kSupervisedUserCustodianName))
 671       .Release();
 672 }
 673
 674 static jstring GetSupervisedUserCustodianEmail(JNIEnv* env, jobject obj) {
 675   return ConvertUTF8ToJavaString(
 676       env, GetPrefService()->GetString(prefs::kSupervisedUserCustodianEmail))
 677       .Release();
 678 }
 679
 680 static jstring GetSupervisedUserCustodianProfileImageURL(JNIEnv* env,
 681                                                          jobject obj) {
 682   return ConvertUTF8ToJavaString(
 683       env,
 684       GetPrefService()->GetString(
 685           prefs::kSupervisedUserCustodianProfileImageURL)).Release();
 686 }
 687
 688 static jstring GetSupervisedUserSecondCustodianName(JNIEnv* env, jobject obj) {
 689   return ConvertUTF8ToJavaString(
 690       env,
 691       GetPrefService()->GetString(prefs::kSupervisedUserSecondCustodianName))
 692       .Release();
 693 }
 694
 695 static jstring GetSupervisedUserSecondCustodianEmail(JNIEnv* env, jobject obj) {
 696   return ConvertUTF8ToJavaString(
 697       env,
 698       GetPrefService()->GetString(prefs::kSupervisedUserSecondCustodianEmail))
 699       .Release();
 700 }
 701
 702 static jstring GetSupervisedUserSecondCustodianProfileImageURL(JNIEnv* env,
 703                                                                jobject obj) {
 704   return ConvertUTF8ToJavaString(
 705       env,
 706       GetPrefService()->GetString(
 707           prefs::kSupervisedUserSecondCustodianProfileImageURL)).Release();
 708 }
 709
 710 bool RegisterPrefServiceBridge(JNIEnv* env) {
 711   return RegisterNativesImpl(env);
 712 }