Update extension preference API.

chrome/browser/extensions/api/preference/preference_api.cc

 // Copyright (c) 2012 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/extensions/api/preference/preference_api.h"
 
 #include <map>
 #include <utility>
 
 #include "base/lazy_instance.h"
 #include "base/memory/singleton.h"
 #include "base/prefs/pref_service.h"
 #include "base/profiler/scoped_profile.h"
 #include "base/stl_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/values.h"
 #include "chrome/browser/chrome_notification_types.h"
 #include "chrome/browser/extensions/api/content_settings/content_settings_service.h"
 #include "chrome/browser/extensions/api/preference/preference_api_constants.h"
 #include "chrome/browser/extensions/api/preference/preference_helpers.h"
 #include "chrome/browser/extensions/api/proxy/proxy_api.h"
 #include "chrome/browser/extensions/extension_service.h"
+#include "chrome/browser/net/prediction_options.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/common/pref_names.h"
 #include "components/translate/core/common/translate_pref_names.h"
 #include "content/public/browser/notification_details.h"
 #include "content/public/browser/notification_source.h"
 #include "extensions/browser/extension_pref_value_map.h"
 #include "extensions/browser/extension_pref_value_map_factory.h"
 #include "extensions/browser/extension_prefs.h"
 #include "extensions/browser/extension_prefs_factory.h"
 #include "extensions/browser/extension_system_provider.h"
@@ skipping 35 matching lines @@
     "Internal error: Stored value for preference '*' cannot be converted "
     "properly.";
 
 PrefMappingEntry kPrefMapping[] = {
     {"alternateErrorPagesEnabled", prefs::kAlternateErrorPagesEnabled,
      APIPermission::kPrivacy, APIPermission::kPrivacy},
     {"autofillEnabled", autofill::prefs::kAutofillEnabled,
      APIPermission::kPrivacy, APIPermission::kPrivacy},
     {"hyperlinkAuditingEnabled", prefs::kEnableHyperlinkAuditing,
      APIPermission::kPrivacy, APIPermission::kPrivacy},
-    {"networkPredictionEnabled", prefs::kNetworkPredictionEnabled,
-     APIPermission::kPrivacy, APIPermission::kPrivacy},
-    {"networkPredictionOptions", prefs::kNetworkPredictionOptions,
+    {"networkPredictionEnabled", prefs::kNetworkPredictionOptions,
      APIPermission::kPrivacy, APIPermission::kPrivacy},
     {"passwordSavingEnabled",
      password_manager::prefs::kPasswordManagerSavingEnabled,
      APIPermission::kPrivacy, APIPermission::kPrivacy},
     {"protectedContentEnabled", prefs::kEnableDRM, APIPermission::kPrivacy,
      APIPermission::kPrivacy},
     {"proxy", prefs::kProxy, APIPermission::kProxy, APIPermission::kProxy},
     {"referrersEnabled", prefs::kEnableReferrers, APIPermission::kPrivacy,
      APIPermission::kPrivacy},
     {"safeBrowsingEnabled", prefs::kSafeBrowsingEnabled,
@@ skipping 60 matching lines @@
 
  private:
   static base::Value* InvertBooleanValue(const base::Value* value) {
     bool bool_value = false;
     bool result = value->GetAsBoolean(&bool_value);
     DCHECK(result);
     return new base::FundamentalValue(!bool_value);
   }
 };
 
+class NetworkPredictionTransformer : public PrefTransformerInterface {
+ public:
+  virtual base::Value* ExtensionToBrowserPref(const base::Value* extension_pref,
+                                              std::string* error,
+                                              bool* bad_message) override {
+    bool bool_value = false;
+    DCHECK(extension_pref->GetAsBoolean(&bool_value));
+    if (bool_value) {
+      return new base::FundamentalValue(
+          chrome_browser_net::NETWORK_PREDICTION_DEFAULT);
+    } else {
+      return new base::FundamentalValue(
+          chrome_browser_net::NETWORK_PREDICTION_NEVER);
+    }
+  }
+
+  virtual base::Value* BrowserToExtensionPref(
+      const base::Value* browser_pref) override {
+    int int_value = chrome_browser_net::NETWORK_PREDICTION_NEVER;
+    DCHECK(browser_pref->GetAsInteger(&int_value));
+    return new base::FundamentalValue(
+        int_value != chrome_browser_net::NETWORK_PREDICTION_NEVER);
+  }
+};
+
 class PrefMapping {
  public:
   static PrefMapping* GetInstance() {
     return Singleton<PrefMapping>::get();
   }
 
   bool FindBrowserPrefForExtensionPref(const std::string& extension_pref,
                                        std::string* browser_pref,
                                        APIPermission::ID* read_permission,
                                        APIPermission::ID* write_permission) {
@@ skipping 45 matching lines @@
       event_mapping_[kPrefMapping[i].browser_pref] =
           PrefMapData(event_name,
                       kPrefMapping[i].read_permission,
                       kPrefMapping[i].write_permission);
     }
     DCHECK_EQ(arraysize(kPrefMapping), mapping_.size());
     DCHECK_EQ(arraysize(kPrefMapping), event_mapping_.size());
     RegisterPrefTransformer(prefs::kProxy, new ProxyPrefTransformer());
     RegisterPrefTransformer(prefs::kBlockThirdPartyCookies,
                             new InvertBooleanTransformer());
+    RegisterPrefTransformer(prefs::kNetworkPredictionOptions,
+                            new NetworkPredictionTransformer());
   }
 
   ~PrefMapping() {
     STLDeleteContainerPairSecondPointers(transformers_.begin(),
                                          transformers_.end());
   }
 
   void RegisterPrefTransformer(const std::string& browser_pref,
                                PrefTransformerInterface* transformer) {
     DCHECK_EQ(0u, transformers_.count(browser_pref)) <<
@@ skipping 407 matching lines @@
   if (!ValidateBrowserPref(
           pref_key, PreferenceFunction::PERMISSION_TYPE_WRITE, &browser_pref)) {
     return false;
   }
   ExtensionPrefs* prefs = ExtensionPrefs::Get(GetProfile());
   const PrefService::Preference* pref =
       prefs->pref_service()->FindPreference(browser_pref.c_str());
   CHECK(pref);
 
   // Validate new value.
-  EXTENSION_FUNCTION_VALIDATE(value->GetType() == pref->GetType());
   PrefTransformerInterface* transformer =
       PrefMapping::GetInstance()->FindTransformerForBrowserPref(browser_pref);
   std::string error;
   bool bad_message = false;
   scoped_ptr<base::Value> browser_pref_value(
       transformer->ExtensionToBrowserPref(value, &error, &bad_message));
   if (!browser_pref_value) {
     error_ = error;
     bad_message_ = bad_message;
     return false;
   }
+  EXTENSION_FUNCTION_VALIDATE(browser_pref_value->GetType() == pref->GetType());
 
   // Validate also that the stored value can be converted back by the
   // transformer.
   scoped_ptr<base::Value> extensionPrefValue(
       transformer->BrowserToExtensionPref(browser_pref_value.get()));
   if (!extensionPrefValue) {
     error_ =  ErrorUtils::FormatErrorMessage(kConversionErrorMessage,
                                                       pref->name());
     bad_message_ = true;
     return false;
@@ skipping 42 matching lines @@
           pref_key, PreferenceFunction::PERMISSION_TYPE_WRITE, &browser_pref)) {
     return false;
   }
 
   PreferenceAPI::Get(GetProfile())
       ->RemoveExtensionControlledPref(extension_id(), browser_pref, scope);
   return true;
 }
 
 }  // namespace extensions