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/pref_names.h"
  28 #include "chrome/grit/locale_settings.h"
  29 #include "components/content_settings/core/browser/host_content_settings_map.h"
  30 #include "components/content_settings/core/common/content_settings.h"
  31 #include "components/content_settings/core/common/content_settings_pattern.h"
  32 #include "components/content_settings/core/common/pref_names.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 "components/version_info/version_info.h"
  37 #include "components/web_resource/web_resource_pref_names.h"
  38 #include "content/public/browser/browser_thread.h"
  39 #include "content/public/browser/user_metrics.h"
  40 #include "jni/PrefServiceBridge_jni.h"
  41 #include "ui/base/l10n/l10n_util.h"
  42
  43 using base::android::AttachCurrentThread;
  44 using base::android::CheckException;
  45 using base::android::ConvertJavaStringToUTF8;
  46 using base::android::ConvertUTF8ToJavaString;
  47 using base::android::ScopedJavaLocalRef;
  48 using base::android::ScopedJavaGlobalRef;
  49 using content::BrowserThread;
  50
  51 namespace {
  52
  53 enum NetworkPredictionOptions {
  54   NETWORK_PREDICTION_ALWAYS,
  55   NETWORK_PREDICTION_WIFI_ONLY,
  56   NETWORK_PREDICTION_NEVER,
  57 };
  58
  59 Profile* GetOriginalProfile() {
  60   return ProfileManager::GetActiveUserProfile()->GetOriginalProfile();
  61 }
  62
  63 bool GetBooleanForContentSetting(ContentSettingsType type) {
  64   HostContentSettingsMap* content_settings =
  65       GetOriginalProfile()->GetHostContentSettingsMap();
  66   switch (content_settings->GetDefaultContentSetting(type, NULL)) {
  67     case CONTENT_SETTING_BLOCK:
  68       return false;
  69     case CONTENT_SETTING_ALLOW:
  70       return true;
  71     case CONTENT_SETTING_ASK:
  72     default:
  73       return true;
  74   }
  75 }
  76
  77 std::string GetStringForContentSettingsType(
  78     ContentSetting content_setting) {
  79   switch (content_setting) {
  80     case CONTENT_SETTING_BLOCK:
  81       return "block";
  82     case CONTENT_SETTING_ALLOW:
  83       return "allow";
  84     case CONTENT_SETTING_ASK:
  85       return "ask";
  86     case CONTENT_SETTING_SESSION_ONLY:
  87       return "session";
  88     case CONTENT_SETTING_DETECT_IMPORTANT_CONTENT:
  89       return "detect";
  90     case CONTENT_SETTING_NUM_SETTINGS:
  91       return "num_settings";
  92     case CONTENT_SETTING_DEFAULT:
  93     default:
  94       return "default";
  95   }
  96 }
  97
  98 bool IsContentSettingManaged(ContentSettingsType content_settings_type) {
  99   std::string source;
 100   HostContentSettingsMap* content_settings =
 101       GetOriginalProfile()->GetHostContentSettingsMap();
 102   content_settings->GetDefaultContentSetting(content_settings_type, &source);
 103   HostContentSettingsMap::ProviderType provider =
 104       content_settings->GetProviderTypeFromSource(source);
 105   return provider == HostContentSettingsMap::POLICY_PROVIDER;
 106 }
 107
 108 bool IsContentSettingManagedByCustodian(
 109     ContentSettingsType content_settings_type) {
 110   std::string source;
 111   HostContentSettingsMap* content_settings =
 112       GetOriginalProfile()->GetHostContentSettingsMap();
 113   content_settings->GetDefaultContentSetting(content_settings_type, &source);
 114   HostContentSettingsMap::ProviderType provider =
 115       content_settings->GetProviderTypeFromSource(source);
 116   return provider == HostContentSettingsMap::SUPERVISED_PROVIDER;
 117 }
 118
 119 bool IsContentSettingUserModifiable(ContentSettingsType content_settings_type) {
 120   std::string source;
 121   HostContentSettingsMap* content_settings =
 122       GetOriginalProfile()->GetHostContentSettingsMap();
 123   content_settings->GetDefaultContentSetting(content_settings_type, &source);
 124   HostContentSettingsMap::ProviderType provider =
 125       content_settings->GetProviderTypeFromSource(source);
 126   return provider >= HostContentSettingsMap::PREF_PROVIDER;
 127 }
 128
 129 PrefService* GetPrefService() {
 130   return GetOriginalProfile()->GetPrefs();
 131 }
 132
 133 }  // namespace
 134
 135 // ----------------------------------------------------------------------------
 136 // Native JNI methods
 137 // ----------------------------------------------------------------------------
 138
 139 static jboolean IsContentSettingManaged(JNIEnv* env, jobject obj,
 140     int content_settings_type) {
 141   return IsContentSettingManaged(
 142       static_cast<ContentSettingsType>(content_settings_type));
 143 }
 144
 145 static jboolean IsContentSettingEnabled(JNIEnv* env, jobject obj,
 146     int content_settings_type) {
 147   // Before we migrate functions over to this central function, we must verify
 148   // that the functionality provided below is correct.
 149   DCHECK(content_settings_type == CONTENT_SETTINGS_TYPE_JAVASCRIPT ||
 150          content_settings_type == CONTENT_SETTINGS_TYPE_IMAGES ||
 151          content_settings_type == CONTENT_SETTINGS_TYPE_POPUPS);
 152   ContentSettingsType type =
 153       static_cast<ContentSettingsType>(content_settings_type);
 154   if (type == CONTENT_SETTINGS_TYPE_JAVASCRIPT ||
 155       type == CONTENT_SETTINGS_TYPE_POPUPS)
 156     return GetBooleanForContentSetting(type);
 157
 158   HostContentSettingsMap* content_settings =
 159       GetOriginalProfile()->GetHostContentSettingsMap();
 160   return content_settings->GetDefaultContentSetting(
 161       type, nullptr) == CONTENT_SETTING_ALLOW;
 162 }
 163
 164 static void SetContentSettingEnabled(JNIEnv* env, jobject obj,
 165     int content_settings_type, jboolean allow) {
 166   // Before we migrate functions over to this central function, we must verify
 167   // that the new category supports ALLOW/BLOCK pairs and, if not, handle them.
 168   DCHECK(content_settings_type == CONTENT_SETTINGS_TYPE_JAVASCRIPT ||
 169          content_settings_type == CONTENT_SETTINGS_TYPE_IMAGES ||
 170          content_settings_type == CONTENT_SETTINGS_TYPE_POPUPS);
 171   HostContentSettingsMap* host_content_settings_map =
 172       GetOriginalProfile()->GetHostContentSettingsMap();
 173   host_content_settings_map->SetDefaultContentSetting(
 174       static_cast<ContentSettingsType>(content_settings_type),
 175       allow ? CONTENT_SETTING_ALLOW : CONTENT_SETTING_BLOCK);
 176 }
 177
 178 static void SetContentSettingForPattern(JNIEnv* env, jobject obj,
 179     int content_settings_type, jstring pattern, int setting) {
 180   HostContentSettingsMap* host_content_settings_map =
 181       GetOriginalProfile()->GetHostContentSettingsMap();
 182   host_content_settings_map->SetContentSetting(
 183       ContentSettingsPattern::FromString(ConvertJavaStringToUTF8(env, pattern)),
 184       ContentSettingsPattern::Wildcard(),
 185       static_cast<ContentSettingsType>(content_settings_type),
 186       "",
 187       static_cast<ContentSetting>(setting));
 188 }
 189
 190 static void GetContentSettingsExceptions(JNIEnv* env, jobject obj,
 191     int content_settings_type, jobject list) {
 192   HostContentSettingsMap* host_content_settings_map =
 193       GetOriginalProfile()->GetHostContentSettingsMap();
 194   ContentSettingsForOneType entries;
 195   host_content_settings_map->GetSettingsForOneType(
 196       static_cast<ContentSettingsType>(content_settings_type), "", &entries);
 197   for (size_t i = 0; i < entries.size(); ++i) {
 198     Java_PrefServiceBridge_addContentSettingExceptionToList(
 199         env, list,
 200         content_settings_type,
 201         ConvertUTF8ToJavaString(
 202             env, entries[i].primary_pattern.ToString()).obj(),
 203         ConvertUTF8ToJavaString(
 204             env, GetStringForContentSettingsType(entries[i].setting)).obj(),
 205         ConvertUTF8ToJavaString(env, entries[i].source).obj());
 206   }
 207 }
 208
 209 static jboolean GetAcceptCookiesEnabled(JNIEnv* env, jobject obj) {
 210   return GetBooleanForContentSetting(CONTENT_SETTINGS_TYPE_COOKIES);
 211 }
 212
 213 static jboolean GetAcceptCookiesManaged(JNIEnv* env, jobject obj) {
 214   return IsContentSettingManaged(CONTENT_SETTINGS_TYPE_COOKIES);
 215 }
 216
 217 static jboolean GetBlockThirdPartyCookiesEnabled(JNIEnv* env, jobject obj) {
 218   return GetPrefService()->GetBoolean(prefs::kBlockThirdPartyCookies);
 219 }
 220
 221 static jboolean GetBlockThirdPartyCookiesManaged(JNIEnv* env, jobject obj) {
 222   return GetPrefService()->IsManagedPreference(prefs::kBlockThirdPartyCookies);
 223 }
 224
 225 static jboolean GetRememberPasswordsEnabled(JNIEnv* env, jobject obj) {
 226   return GetPrefService()->GetBoolean(
 227       password_manager::prefs::kPasswordManagerSavingEnabled);
 228 }
 229
 230 static jboolean GetPasswordManagerAutoSigninEnabled(JNIEnv* env, jobject obj) {
 231   return GetPrefService()->GetBoolean(
 232       password_manager::prefs::kPasswordManagerAutoSignin);
 233 }
 234
 235 static jboolean GetRememberPasswordsManaged(JNIEnv* env, jobject obj) {
 236   return GetPrefService()->IsManagedPreference(
 237       password_manager::prefs::kPasswordManagerSavingEnabled);
 238 }
 239
 240 static jboolean GetPasswordManagerAutoSigninManaged(JNIEnv* env, jobject obj) {
 241   return GetPrefService()->IsManagedPreference(
 242       password_manager::prefs::kPasswordManagerAutoSignin);
 243 }
 244
 245 static jboolean GetDoNotTrackEnabled(JNIEnv* env, jobject obj) {
 246   return GetPrefService()->GetBoolean(prefs::kEnableDoNotTrack);
 247 }
 248
 249 static jint GetNetworkPredictionOptions(JNIEnv* env, jobject obj) {
 250   return GetPrefService()->GetInteger(prefs::kNetworkPredictionOptions);
 251 }
 252
 253 static jboolean GetNetworkPredictionManaged(JNIEnv* env, jobject obj) {
 254   return GetPrefService()->IsManagedPreference(
 255       prefs::kNetworkPredictionOptions);
 256 }
 257
 258 static jboolean GetPasswordEchoEnabled(JNIEnv* env, jobject obj) {
 259   return GetPrefService()->GetBoolean(prefs::kWebKitPasswordEchoEnabled);
 260 }
 261
 262 static jboolean GetPrintingEnabled(JNIEnv* env, jobject obj) {
 263   return GetPrefService()->GetBoolean(prefs::kPrintingEnabled);
 264 }
 265
 266 static jboolean GetPrintingManaged(JNIEnv* env, jobject obj) {
 267   return GetPrefService()->IsManagedPreference(prefs::kPrintingEnabled);
 268 }
 269
 270 static jboolean GetTranslateEnabled(JNIEnv* env, jobject obj) {
 271   return GetPrefService()->GetBoolean(prefs::kEnableTranslate);
 272 }
 273
 274 static jboolean GetTranslateManaged(JNIEnv* env, jobject obj) {
 275   return GetPrefService()->IsManagedPreference(prefs::kEnableTranslate);
 276 }
 277
 278 static jboolean GetAutoDetectEncodingEnabled(JNIEnv* env, jobject obj) {
 279   return GetPrefService()->GetBoolean(prefs::kWebKitUsesUniversalDetector);
 280 }
 281
 282 static jboolean GetSearchSuggestEnabled(JNIEnv* env, jobject obj) {
 283   return GetPrefService()->GetBoolean(prefs::kSearchSuggestEnabled);
 284 }
 285
 286 static jboolean GetSearchSuggestManaged(JNIEnv* env, jobject obj) {
 287   return GetPrefService()->IsManagedPreference(prefs::kSearchSuggestEnabled);
 288 }
 289
 290 static jboolean GetSafeBrowsingExtendedReportingEnabled(JNIEnv* env,
 291                                                         jobject obj) {
 292   return GetPrefService()->GetBoolean(
 293       prefs::kSafeBrowsingExtendedReportingEnabled);
 294 }
 295
 296 static void SetSafeBrowsingExtendedReportingEnabled(JNIEnv* env,
 297                                                     jobject obj,
 298                                                     jboolean enabled) {
 299   GetPrefService()->SetBoolean(prefs::kSafeBrowsingExtendedReportingEnabled,
 300                                enabled);
 301 }
 302
 303 static jboolean GetSafeBrowsingExtendedReportingManaged(JNIEnv* env,
 304                                                         jobject obj) {
 305   return GetPrefService()->IsManagedPreference(
 306       prefs::kSafeBrowsingExtendedReportingEnabled);
 307 }
 308
 309 static jboolean GetSafeBrowsingEnabled(JNIEnv* env, jobject obj) {
 310   return GetPrefService()->GetBoolean(prefs::kSafeBrowsingEnabled);
 311 }
 312
 313 static void SetSafeBrowsingEnabled(JNIEnv* env, jobject obj, jboolean enabled) {
 314   GetPrefService()->SetBoolean(prefs::kSafeBrowsingEnabled, enabled);
 315 }
 316
 317 static jboolean GetSafeBrowsingManaged(JNIEnv* env, jobject obj) {
 318   return GetPrefService()->IsManagedPreference(prefs::kSafeBrowsingEnabled);
 319 }
 320
 321 static jboolean GetProtectedMediaIdentifierEnabled(JNIEnv* env, jobject obj) {
 322   return GetBooleanForContentSetting(
 323       CONTENT_SETTINGS_TYPE_PROTECTED_MEDIA_IDENTIFIER);
 324 }
 325
 326 static jboolean GetPushNotificationsEnabled(JNIEnv* env, jobject obj) {
 327   return GetBooleanForContentSetting(CONTENT_SETTINGS_TYPE_NOTIFICATIONS);
 328 }
 329
 330 static jboolean GetAllowLocationEnabled(JNIEnv* env, jobject obj) {
 331   return GetBooleanForContentSetting(CONTENT_SETTINGS_TYPE_GEOLOCATION);
 332 }
 333
 334 static jboolean GetLocationAllowedByPolicy(JNIEnv* env, jobject obj) {
 335   if (!IsContentSettingManaged(CONTENT_SETTINGS_TYPE_GEOLOCATION))
 336     return false;
 337   HostContentSettingsMap* content_settings =
 338       GetOriginalProfile()->GetHostContentSettingsMap();
 339   return content_settings->GetDefaultContentSetting(
 340              CONTENT_SETTINGS_TYPE_GEOLOCATION, nullptr) ==
 341          CONTENT_SETTING_ALLOW;
 342 }
 343
 344 static jboolean GetAllowLocationUserModifiable(JNIEnv* env, jobject obj) {
 345   return IsContentSettingUserModifiable(CONTENT_SETTINGS_TYPE_GEOLOCATION);
 346 }
 347
 348 static jboolean GetAllowLocationManagedByCustodian(JNIEnv* env, jobject obj) {
 349   return IsContentSettingManagedByCustodian(CONTENT_SETTINGS_TYPE_GEOLOCATION);
 350 }
 351
 352 static jboolean GetResolveNavigationErrorEnabled(JNIEnv* env, jobject obj) {
 353   return GetPrefService()->GetBoolean(prefs::kAlternateErrorPagesEnabled);
 354 }
 355
 356 static jboolean GetResolveNavigationErrorManaged(JNIEnv* env, jobject obj) {
 357   return GetPrefService()->IsManagedPreference(
 358       prefs::kAlternateErrorPagesEnabled);
 359 }
 360
 361 static jboolean GetCrashReportManaged(JNIEnv* env, jobject obj) {
 362   return GetPrefService()->IsManagedPreference(
 363       prefs::kCrashReportingEnabled);
 364 }
 365
 366 static jboolean GetForceGoogleSafeSearch(JNIEnv* env, jobject obj) {
 367   return GetPrefService()->GetBoolean(prefs::kForceGoogleSafeSearch);
 368 }
 369
 370 static jint GetDefaultSupervisedUserFilteringBehavior(JNIEnv* env,
 371                                                       jobject obj) {
 372   return GetPrefService()->GetInteger(
 373       prefs::kDefaultSupervisedUserFilteringBehavior);
 374 }
 375
 376 static jboolean GetIncognitoModeEnabled(JNIEnv* env, jobject obj) {
 377   PrefService* prefs = GetPrefService();
 378   IncognitoModePrefs::Availability incognito_pref =
 379       IncognitoModePrefs::GetAvailability(prefs);
 380   DCHECK(incognito_pref == IncognitoModePrefs::ENABLED ||
 381          incognito_pref == IncognitoModePrefs::DISABLED) <<
 382              "Unsupported incognito mode preference: " << incognito_pref;
 383   return incognito_pref != IncognitoModePrefs::DISABLED;
 384 }
 385
 386 static jboolean GetIncognitoModeManaged(JNIEnv* env, jobject obj) {
 387   return GetPrefService()->IsManagedPreference(
 388       prefs::kIncognitoModeAvailability);
 389 }
 390
 391 static jboolean GetFullscreenManaged(JNIEnv* env, jobject obj) {
 392   return IsContentSettingManaged(CONTENT_SETTINGS_TYPE_FULLSCREEN);
 393 }
 394
 395 static jboolean GetFullscreenAllowed(JNIEnv* env, jobject obj) {
 396   HostContentSettingsMap* content_settings =
 397       GetOriginalProfile()->GetHostContentSettingsMap();
 398   return content_settings->GetDefaultContentSetting(
 399       CONTENT_SETTINGS_TYPE_FULLSCREEN, NULL) == CONTENT_SETTING_ALLOW;
 400 }
 401
 402 static jboolean GetMetricsReportingEnabled(JNIEnv* env, jobject obj) {
 403   PrefService* local_state = g_browser_process->local_state();
 404   return local_state->GetBoolean(prefs::kMetricsReportingEnabled);
 405 }
 406
 407 static void SetMetricsReportingEnabled(JNIEnv* env,
 408                                        jobject obj,
 409                                        jboolean enabled) {
 410   PrefService* local_state = g_browser_process->local_state();
 411   local_state->SetBoolean(prefs::kMetricsReportingEnabled, enabled);
 412 }
 413
 414 static jboolean HasSetMetricsReporting(JNIEnv* env, jobject obj) {
 415   PrefService* local_state = g_browser_process->local_state();
 416   return local_state->HasPrefPath(prefs::kMetricsReportingEnabled);
 417 }
 418
 419 namespace {
 420
 421 // Redirects a BrowsingDataRemover completion callback back into Java.
 422 class ClearBrowsingDataObserver : public BrowsingDataRemover::Observer {
 423  public:
 424   // |obj| is expected to be the object passed into ClearBrowsingData(); e.g. a
 425   // ChromePreference.
 426   ClearBrowsingDataObserver(JNIEnv* env, jobject obj)
 427       : weak_chrome_native_preferences_(env, obj) {
 428   }
 429
 430   void OnBrowsingDataRemoverDone() override {
 431     // Just as a BrowsingDataRemover deletes itself when done, we delete ourself
 432     // when done.  No need to remove ourself as an observer given the lifetime
 433     // of BrowsingDataRemover.
 434     scoped_ptr<ClearBrowsingDataObserver> auto_delete(this);
 435
 436     JNIEnv* env = AttachCurrentThread();
 437     if (weak_chrome_native_preferences_.get(env).is_null())
 438       return;
 439
 440     Java_PrefServiceBridge_browsingDataCleared(
 441         env, weak_chrome_native_preferences_.get(env).obj());
 442   }
 443
 444  private:
 445   JavaObjectWeakGlobalRef weak_chrome_native_preferences_;
 446 };
 447 }  // namespace
 448
 449 static void ClearBrowsingData(JNIEnv* env, jobject obj, jboolean history,
 450     jboolean cache, jboolean cookies_and_site_data, jboolean passwords,
 451     jboolean form_data) {
 452   // BrowsingDataRemover deletes itself.
 453   BrowsingDataRemover* browsing_data_remover =
 454       BrowsingDataRemover::CreateForPeriod(
 455           GetOriginalProfile(),
 456           static_cast<BrowsingDataRemover::TimePeriod>(
 457               BrowsingDataRemover::EVERYTHING));
 458   browsing_data_remover->AddObserver(new ClearBrowsingDataObserver(env, obj));
 459
 460   int remove_mask = 0;
 461   if (history)
 462     remove_mask |= BrowsingDataRemover::REMOVE_HISTORY;
 463   if (cache)
 464     remove_mask |= BrowsingDataRemover::REMOVE_CACHE;
 465   if (cookies_and_site_data) {
 466     remove_mask |= BrowsingDataRemover::REMOVE_COOKIES;
 467     remove_mask |= BrowsingDataRemover::REMOVE_SITE_DATA;
 468   }
 469   if (passwords)
 470     remove_mask |= BrowsingDataRemover::REMOVE_PASSWORDS;
 471   if (form_data)
 472     remove_mask |= BrowsingDataRemover::REMOVE_FORM_DATA;
 473   browsing_data_remover->Remove(remove_mask,
 474                                 BrowsingDataHelper::UNPROTECTED_WEB);
 475 }
 476
 477 static jboolean CanDeleteBrowsingHistory(JNIEnv* env, jobject obj) {
 478   return GetPrefService()->GetBoolean(prefs::kAllowDeletingBrowserHistory);
 479 }
 480
 481 static void SetAllowCookiesEnabled(JNIEnv* env, jobject obj, jboolean allow) {
 482   HostContentSettingsMap* host_content_settings_map =
 483       GetOriginalProfile()->GetHostContentSettingsMap();
 484   host_content_settings_map->SetDefaultContentSetting(
 485       CONTENT_SETTINGS_TYPE_COOKIES,
 486       allow ? CONTENT_SETTING_ALLOW : CONTENT_SETTING_BLOCK);
 487 }
 488
 489 static void SetBlockThirdPartyCookiesEnabled(JNIEnv* env, jobject obj,
 490                                              jboolean enabled) {
 491   GetPrefService()->SetBoolean(prefs::kBlockThirdPartyCookies, enabled);
 492 }
 493
 494 static void SetRememberPasswordsEnabled(JNIEnv* env, jobject obj,
 495                                         jboolean allow) {
 496   GetPrefService()->SetBoolean(
 497       password_manager::prefs::kPasswordManagerSavingEnabled, allow);
 498 }
 499
 500 static void SetPasswordManagerAutoSigninEnabled(JNIEnv* env,
 501                                                 jobject obj,
 502                                                 jboolean enabled) {
 503   GetPrefService()->SetBoolean(
 504       password_manager::prefs::kPasswordManagerAutoSignin, enabled);
 505 }
 506
 507 static void SetProtectedMediaIdentifierEnabled(JNIEnv* env,
 508                                                jobject obj,
 509                                                jboolean is_enabled) {
 510   HostContentSettingsMap* host_content_settings_map =
 511       GetOriginalProfile()->GetHostContentSettingsMap();
 512   host_content_settings_map->SetDefaultContentSetting(
 513       CONTENT_SETTINGS_TYPE_PROTECTED_MEDIA_IDENTIFIER,
 514       is_enabled ? CONTENT_SETTING_ASK : CONTENT_SETTING_BLOCK);
 515 }
 516
 517 static void SetAllowLocationEnabled(JNIEnv* env,
 518                                     jobject obj,
 519                                     jboolean is_enabled) {
 520   HostContentSettingsMap* host_content_settings_map =
 521       GetOriginalProfile()->GetHostContentSettingsMap();
 522   host_content_settings_map->SetDefaultContentSetting(
 523       CONTENT_SETTINGS_TYPE_GEOLOCATION,
 524       is_enabled ? CONTENT_SETTING_ASK : CONTENT_SETTING_BLOCK);
 525 }
 526
 527 static void SetCameraEnabled(JNIEnv* env, jobject obj, jboolean allow) {
 528   HostContentSettingsMap* host_content_settings_map =
 529       GetOriginalProfile()->GetHostContentSettingsMap();
 530   host_content_settings_map->SetDefaultContentSetting(
 531       CONTENT_SETTINGS_TYPE_MEDIASTREAM_CAMERA,
 532       allow ? CONTENT_SETTING_ASK : CONTENT_SETTING_BLOCK);
 533 }
 534
 535 static void SetMicEnabled(JNIEnv* env, jobject obj, jboolean allow) {
 536   HostContentSettingsMap* host_content_settings_map =
 537       GetOriginalProfile()->GetHostContentSettingsMap();
 538   host_content_settings_map->SetDefaultContentSetting(
 539       CONTENT_SETTINGS_TYPE_MEDIASTREAM_MIC,
 540       allow ? CONTENT_SETTING_ASK : CONTENT_SETTING_BLOCK);
 541 }
 542
 543 static void SetFullscreenAllowed(JNIEnv* env, jobject obj, jboolean allow) {
 544   HostContentSettingsMap* host_content_settings_map =
 545       GetOriginalProfile()->GetHostContentSettingsMap();
 546   host_content_settings_map->SetDefaultContentSetting(
 547       CONTENT_SETTINGS_TYPE_FULLSCREEN,
 548       allow ? CONTENT_SETTING_ALLOW : CONTENT_SETTING_ASK);
 549 }
 550
 551 static void SetPushNotificationsEnabled(JNIEnv* env,
 552                                         jobject obj,
 553                                         jboolean allow) {
 554   HostContentSettingsMap* host_content_settings_map =
 555       GetOriginalProfile()->GetHostContentSettingsMap();
 556   host_content_settings_map->SetDefaultContentSetting(
 557       CONTENT_SETTINGS_TYPE_NOTIFICATIONS,
 558       allow ? CONTENT_SETTING_ASK : CONTENT_SETTING_BLOCK);
 559 }
 560
 561 static void SetCrashReporting(JNIEnv* env, jobject obj, jboolean reporting) {
 562   PrefService* local_state = g_browser_process->local_state();
 563   local_state->SetBoolean(prefs::kCrashReportingEnabled, reporting);
 564 }
 565
 566 static jboolean CanPredictNetworkActions(JNIEnv* env, jobject obj) {
 567   return chrome_browser_net::CanPrefetchAndPrerenderUI(GetPrefService());
 568 }
 569
 570 static void SetDoNotTrackEnabled(JNIEnv* env, jobject obj, jboolean allow) {
 571   GetPrefService()->SetBoolean(prefs::kEnableDoNotTrack, allow);
 572 }
 573
 574 static jstring GetSyncLastAccountName(JNIEnv* env, jobject obj) {
 575   return ConvertUTF8ToJavaString(
 576       env, GetPrefService()->GetString(prefs::kGoogleServicesLastUsername))
 577       .Release();
 578 }
 579
 580 static void SetTranslateEnabled(JNIEnv* env, jobject obj, jboolean enabled) {
 581   GetPrefService()->SetBoolean(prefs::kEnableTranslate, enabled);
 582 }
 583
 584 static void SetAutoDetectEncodingEnabled(JNIEnv* env, jobject obj,
 585                                          jboolean enabled) {
 586   content::RecordAction(base::UserMetricsAction("AutoDetectChange"));
 587   GetPrefService()->SetBoolean(prefs::kWebKitUsesUniversalDetector, enabled);
 588 }
 589
 590 static void ResetTranslateDefaults(JNIEnv* env, jobject obj) {
 591   scoped_ptr<translate::TranslatePrefs> translate_prefs =
 592       ChromeTranslateClient::CreateTranslatePrefs(GetPrefService());
 593   translate_prefs->ResetToDefaults();
 594 }
 595
 596 static void MigrateJavascriptPreference(JNIEnv* env, jobject obj) {
 597   const PrefService::Preference* javascript_pref =
 598       GetPrefService()->FindPreference(prefs::kWebKitJavascriptEnabled);
 599   DCHECK(javascript_pref);
 600
 601   if (!javascript_pref->HasUserSetting())
 602     return;
 603
 604   bool javascript_enabled = false;
 605   bool retval = javascript_pref->GetValue()->GetAsBoolean(&javascript_enabled);
 606   DCHECK(retval);
 607   SetContentSettingEnabled(env, obj,
 608       CONTENT_SETTINGS_TYPE_JAVASCRIPT, javascript_enabled);
 609   GetPrefService()->ClearPref(prefs::kWebKitJavascriptEnabled);
 610 }
 611
 612 static void MigrateLocationPreference(JNIEnv* env, jobject obj) {
 613   const PrefService::Preference* pref =
 614       GetPrefService()->FindPreference(prefs::kGeolocationEnabled);
 615   if (!pref || !pref->HasUserSetting())
 616     return;
 617   bool location_enabled = false;
 618   bool retval = pref->GetValue()->GetAsBoolean(&location_enabled);
 619   DCHECK(retval);
 620   // Do a restrictive migration. GetAllowLocationEnabled could be
 621   // non-usermodifiable and we don't want to migrate that.
 622   if (!location_enabled)
 623     SetAllowLocationEnabled(env, obj, false);
 624   GetPrefService()->ClearPref(prefs::kGeolocationEnabled);
 625 }
 626
 627 static void MigrateProtectedMediaPreference(JNIEnv* env, jobject obj) {
 628   const PrefService::Preference* pref =
 629       GetPrefService()->FindPreference(prefs::kProtectedMediaIdentifierEnabled);
 630   if (!pref || !pref->HasUserSetting())
 631     return;
 632   bool pmi_enabled = false;
 633   bool retval = pref->GetValue()->GetAsBoolean(&pmi_enabled);
 634   DCHECK(retval);
 635   // Do a restrictive migration if values disagree.
 636   if (!pmi_enabled)
 637     SetProtectedMediaIdentifierEnabled(env, obj, false);
 638   GetPrefService()->ClearPref(prefs::kProtectedMediaIdentifierEnabled);
 639 }
 640
 641 static void SetPasswordEchoEnabled(JNIEnv* env,
 642                                    jobject obj,
 643                                    jboolean passwordEchoEnabled) {
 644   GetPrefService()->SetBoolean(prefs::kWebKitPasswordEchoEnabled,
 645                                passwordEchoEnabled);
 646 }
 647
 648 static jboolean GetCameraEnabled(JNIEnv* env, jobject obj) {
 649   return GetBooleanForContentSetting(CONTENT_SETTINGS_TYPE_MEDIASTREAM_CAMERA);
 650 }
 651
 652 static jboolean GetCameraUserModifiable(JNIEnv* env, jobject obj) {
 653   return IsContentSettingUserModifiable(
 654              CONTENT_SETTINGS_TYPE_MEDIASTREAM_CAMERA);
 655 }
 656
 657 static jboolean GetCameraManagedByCustodian(JNIEnv* env, jobject obj) {
 658   return IsContentSettingManagedByCustodian(
 659              CONTENT_SETTINGS_TYPE_MEDIASTREAM_CAMERA);
 660 }
 661
 662 static jboolean GetMicEnabled(JNIEnv* env, jobject obj) {
 663   return GetBooleanForContentSetting(CONTENT_SETTINGS_TYPE_MEDIASTREAM_MIC);
 664 }
 665
 666 static jboolean GetMicUserModifiable(JNIEnv* env, jobject obj) {
 667   return IsContentSettingUserModifiable(
 668              CONTENT_SETTINGS_TYPE_MEDIASTREAM_MIC);
 669 }
 670
 671 static jboolean GetMicManagedByCustodian(JNIEnv* env, jobject obj) {
 672   return IsContentSettingManagedByCustodian(
 673              CONTENT_SETTINGS_TYPE_MEDIASTREAM_MIC);
 674 }
 675
 676 static void SetJavaScriptAllowed(JNIEnv* env, jobject obj, jstring pattern,
 677                                  int setting) {
 678   HostContentSettingsMap* host_content_settings_map =
 679       GetOriginalProfile()->GetHostContentSettingsMap();
 680   host_content_settings_map->SetContentSetting(
 681       ContentSettingsPattern::FromString(ConvertJavaStringToUTF8(env, pattern)),
 682       ContentSettingsPattern::Wildcard(),
 683       CONTENT_SETTINGS_TYPE_JAVASCRIPT,
 684       "",
 685       static_cast<ContentSetting>(setting));
 686 }
 687
 688 static void SetPopupException(JNIEnv* env, jobject obj, jstring pattern,
 689                               int setting) {
 690   HostContentSettingsMap* host_content_settings_map =
 691       GetOriginalProfile()->GetHostContentSettingsMap();
 692   host_content_settings_map->SetContentSetting(
 693       ContentSettingsPattern::FromString(ConvertJavaStringToUTF8(env, pattern)),
 694       ContentSettingsPattern::Wildcard(),
 695       CONTENT_SETTINGS_TYPE_POPUPS,
 696       "",
 697       static_cast<ContentSetting>(setting));
 698 }
 699
 700 static void SetSearchSuggestEnabled(JNIEnv* env, jobject obj,
 701                                     jboolean enabled) {
 702   GetPrefService()->SetBoolean(prefs::kSearchSuggestEnabled, enabled);
 703 }
 704
 705 static jstring GetContextualSearchPreference(JNIEnv* env, jobject obj) {
 706   return ConvertUTF8ToJavaString(
 707       env, GetPrefService()->GetString(prefs::kContextualSearchEnabled)).
 708           Release();
 709 }
 710
 711 static jboolean GetContextualSearchPreferenceIsManaged(JNIEnv* env,
 712                                                        jobject obj) {
 713   return GetPrefService()->IsManagedPreference(prefs::kContextualSearchEnabled);
 714 }
 715
 716 static void SetContextualSearchPreference(JNIEnv* env, jobject obj,
 717                                           jstring pref) {
 718   GetPrefService()->SetString(prefs::kContextualSearchEnabled,
 719       ConvertJavaStringToUTF8(env, pref));
 720 }
 721
 722 static void SetNetworkPredictionOptions(JNIEnv* env, jobject obj, int option) {
 723   GetPrefService()->SetInteger(prefs::kNetworkPredictionOptions, option);
 724 }
 725
 726 static jboolean NetworkPredictionEnabledHasUserSetting(JNIEnv* env,
 727                                                        jobject obj) {
 728   return GetPrefService()->GetUserPrefValue(
 729       prefs::kNetworkPredictionEnabled) != NULL;
 730 }
 731
 732 static jboolean NetworkPredictionOptionsHasUserSetting(JNIEnv* env,
 733                                                        jobject obj) {
 734   return GetPrefService()->GetUserPrefValue(
 735       prefs::kNetworkPredictionOptions) != NULL;
 736 }
 737
 738 static jboolean GetNetworkPredictionEnabledUserPrefValue(JNIEnv* env,
 739                                                          jobject obj) {
 740   const base::Value* network_prediction_enabled =
 741       GetPrefService()->GetUserPrefValue(prefs::kNetworkPredictionEnabled);
 742   DCHECK(network_prediction_enabled);
 743   bool value = false;
 744   DCHECK(network_prediction_enabled->GetAsBoolean(&value));
 745   return value;
 746 }
 747
 748 static void SetResolveNavigationErrorEnabled(JNIEnv* env, jobject obj,
 749                                              jboolean enabled) {
 750   GetPrefService()->SetBoolean(prefs::kAlternateErrorPagesEnabled, enabled);
 751 }
 752
 753 static jboolean GetFirstRunEulaAccepted(JNIEnv* env, jobject obj) {
 754   return g_browser_process->local_state()->GetBoolean(prefs::kEulaAccepted);
 755 }
 756
 757 static void SetEulaAccepted(JNIEnv* env, jobject obj) {
 758   g_browser_process->local_state()->SetBoolean(prefs::kEulaAccepted, true);
 759 }
 760
 761 static void ResetAcceptLanguages(JNIEnv* env,
 762                                  jobject obj,
 763                                  jstring default_locale) {
 764   std::string accept_languages(l10n_util::GetStringUTF8(IDS_ACCEPT_LANGUAGES));
 765   std::string locale_string(ConvertJavaStringToUTF8(env, default_locale));
 766
 767   PrefServiceBridge::PrependToAcceptLanguagesIfNecessary(locale_string,
 768                                                          &accept_languages);
 769   GetPrefService()->SetString(prefs::kAcceptLanguages, accept_languages);
 770 }
 771
 772 // Sends all information about the different versions to Java.
 773 // From browser_about_handler.cc
 774 static jobject GetAboutVersionStrings(JNIEnv* env, jobject obj) {
 775   std::string os_version = version_info::GetOSType();
 776   os_version += " " + AndroidAboutAppInfo::GetOsInfo();
 777
 778   base::android::BuildInfo* android_build_info =
 779         base::android::BuildInfo::GetInstance();
 780   std::string application(android_build_info->package_label());
 781   application.append(" ");
 782   application.append(version_info::GetVersionNumber());
 783
 784   // OK to release, returning to Java.
 785   return Java_PrefServiceBridge_createAboutVersionStrings(
 786       env,
 787       ConvertUTF8ToJavaString(env, application).obj(),
 788       ConvertUTF8ToJavaString(env, os_version).obj()).Release();
 789 }
 790
 791 static jstring GetSupervisedUserCustodianName(JNIEnv* env, jobject obj) {
 792   return ConvertUTF8ToJavaString(
 793       env, GetPrefService()->GetString(prefs::kSupervisedUserCustodianName))
 794       .Release();
 795 }
 796
 797 static jstring GetSupervisedUserCustodianEmail(JNIEnv* env, jobject obj) {
 798   return ConvertUTF8ToJavaString(
 799       env, GetPrefService()->GetString(prefs::kSupervisedUserCustodianEmail))
 800       .Release();
 801 }
 802
 803 static jstring GetSupervisedUserCustodianProfileImageURL(JNIEnv* env,
 804                                                          jobject obj) {
 805   return ConvertUTF8ToJavaString(
 806       env,
 807       GetPrefService()->GetString(
 808           prefs::kSupervisedUserCustodianProfileImageURL)).Release();
 809 }
 810
 811 static jstring GetSupervisedUserSecondCustodianName(JNIEnv* env, jobject obj) {
 812   return ConvertUTF8ToJavaString(
 813       env,
 814       GetPrefService()->GetString(prefs::kSupervisedUserSecondCustodianName))
 815       .Release();
 816 }
 817
 818 static jstring GetSupervisedUserSecondCustodianEmail(JNIEnv* env, jobject obj) {
 819   return ConvertUTF8ToJavaString(
 820       env,
 821       GetPrefService()->GetString(prefs::kSupervisedUserSecondCustodianEmail))
 822       .Release();
 823 }
 824
 825 static jstring GetSupervisedUserSecondCustodianProfileImageURL(JNIEnv* env,
 826                                                                jobject obj) {
 827   return ConvertUTF8ToJavaString(
 828       env,
 829       GetPrefService()->GetString(
 830           prefs::kSupervisedUserSecondCustodianProfileImageURL)).Release();
 831 }
 832
 833 // static
 834 bool PrefServiceBridge::RegisterPrefServiceBridge(JNIEnv* env) {
 835   return RegisterNativesImpl(env);
 836 }
 837
 838 // static
 839 void PrefServiceBridge::PrependToAcceptLanguagesIfNecessary(
 840     const std::string& locale,
 841     std::string* accept_languages) {
 842   if (locale.size() != 5u || locale[2] != '_')  // not well-formed
 843     return;
 844
 845   std::string language(locale.substr(0, 2));
 846   std::string region(locale.substr(3, 2));
 847
 848   // Java mostly follows ISO-639-1 and ICU, except for the following three.
 849   // See documentation on java.util.Locale constructor for more.
 850   if (language == "iw") {
 851     language = "he";
 852   } else if (language == "ji") {
 853     language = "yi";
 854   } else if (language == "in") {
 855     language = "id";
 856   }
 857
 858   std::string language_region(language + "-" + region);
 859
 860   if (accept_languages->find(language_region) == std::string::npos) {
 861     std::vector<std::string> parts;
 862     parts.push_back(language_region);
 863     // If language is not in the accept languages list, also add language code.
 864     if (accept_languages->find(language + ",") == std::string::npos &&
 865         !std::equal(language.rbegin(), language.rend(),
 866                     accept_languages->rbegin())) {
 867       parts.push_back(language);
 868     }
 869     parts.push_back(*accept_languages);
 870     *accept_languages = base::JoinString(parts, ",");
 871   }
 872 }
 873
 874 // static
 875 std::string PrefServiceBridge::GetAndroidPermissionForContentSetting(
 876     ContentSettingsType content_type) {
 877   JNIEnv* env = AttachCurrentThread();
 878   base::android::ScopedJavaLocalRef<jstring> android_permission =
 879       Java_PrefServiceBridge_getAndroidPermissionForContentSetting(
 880           env, content_type);
 881   if (android_permission.is_null())
 882     return std::string();
 883
 884   return ConvertJavaStringToUTF8(android_permission);
 885 }