more changes

chrome/browser/extensions/extension_prefs.cc

 // Copyright (c) 2011 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/extension_prefs.h"
 
 #include "base/string_number_conversions.h"
 #include "base/string_util.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/browser/extensions/extension_pref_store.h"
@@ skipping 412 matching lines @@
   return true;
 }
 
 void ExtensionPrefs::SetExtensionPrefURLPatternSet(
     const std::string& extension_id,
     const std::string& pref_key,
     const URLPatternSet& new_value) {
   ListValue* value = new ListValue();
   for (URLPatternSet::const_iterator i = new_value.begin();
        i != new_value.end(); ++i)
-    value->AppendIfNotPresent(Value::CreateStringValue(i->GetAsString()));
+    value->AppendIfNotPresent(base::StringValue::New(i->GetAsString()));
 
   UpdateExtensionPref(extension_id, pref_key, value);
 }
 
 ExtensionPermissionSet* ExtensionPrefs::ReadExtensionPrefPermissionSet(
     const std::string& extension_id,
     const std::string& pref_key) {
   if (!GetExtensionPref(extension_id))
     return NULL;
 
@@ skipping 34 matching lines @@
     const ExtensionPermissionSet* new_value) {
   // Set the API permissions.
   ListValue* api_values = new ListValue();
   ExtensionAPIPermissionSet apis = new_value->apis();
   ExtensionPermissionsInfo* info = ExtensionPermissionsInfo::GetInstance();
   std::string api_pref = JoinPrefs(pref_key, kPrefAPIs);
   for (ExtensionAPIPermissionSet::const_iterator i = apis.begin();
        i != apis.end(); ++i) {
     ExtensionAPIPermission* perm = info->GetByID(*i);
     if (perm)
-      api_values->Append(Value::CreateStringValue(perm->name()));
+      api_values->Append(base::StringValue::New(perm->name()));
   }
   UpdateExtensionPref(extension_id, api_pref, api_values);
 
   // Set the explicit host permissions.
   if (!new_value->explicit_hosts().is_empty()) {
     SetExtensionPrefURLPatternSet(extension_id,
                                   JoinPrefs(pref_key, kPrefExplicitHosts),
                                   new_value->explicit_hosts());
   }
 
@@ skipping 60 matching lines @@
 
 bool ExtensionPrefs::DidExtensionEscalatePermissions(
     const std::string& extension_id) {
   return ReadExtensionPrefBoolean(extension_id,
                                   kExtensionDidEscalatePermissions);
 }
 
 void ExtensionPrefs::SetDidExtensionEscalatePermissions(
     const Extension* extension, bool did_escalate) {
   UpdateExtensionPref(extension->id(), kExtensionDidEscalatePermissions,
-                      Value::CreateBooleanValue(did_escalate));
+                      base::BooleanValue::New(did_escalate));
 }
 
 void ExtensionPrefs::UpdateBlacklist(
     const std::set<std::string>& blacklist_set) {
   std::vector<std::string> remove_pref_ids;
   std::set<std::string> used_id_set;
   const DictionaryValue* extensions = prefs_->GetDictionary(kExtensionsPref);
 
   if (extensions) {
     for (DictionaryValue::key_iterator extension_id = extensions->begin_keys();
@@ skipping 26 matching lines @@
         // Keep the record if this extension is already processed.
         used_id_set.insert(id);
       }
     }
   }
 
   // Iterate the leftovers to set blacklist in pref
   std::set<std::string>::const_iterator set_itr = blacklist_set.begin();
   for (; set_itr != blacklist_set.end(); ++set_itr) {
     if (used_id_set.find(*set_itr) == used_id_set.end()) {
-      UpdateExtensionPref(*set_itr, kPrefBlacklist,
-                          Value::CreateBooleanValue(true));
+      UpdateExtensionPref(*set_itr, kPrefBlacklist, base::TrueValue());
     }
   }
   for (unsigned int i = 0; i < remove_pref_ids.size(); ++i) {
     DeleteExtensionPrefs(remove_pref_ids[i]);
   }
 }
 
 namespace {
 
 // Serializes |time| as a string value mapped to |key| in |dictionary|.
@@ skipping 59 matching lines @@
   const DictionaryValue* dictionary = GetExtensionPref(extension_id);
   bool result = false;
   if (dictionary && dictionary->GetBoolean(kActiveBit, &result))
     return result;
   return false;
 }
 
 void ExtensionPrefs::SetActiveBit(const std::string& extension_id,
                                   bool active) {
   UpdateExtensionPref(extension_id, kActiveBit,
-                      Value::CreateBooleanValue(active));
+                      base::BooleanValue::New(active));
 }
 
 void ExtensionPrefs::MigratePermissions(const ExtensionIdSet& extension_ids) {
   ExtensionPermissionsInfo* info = ExtensionPermissionsInfo::GetInstance();
   for (ExtensionIdSet::const_iterator ext_id = extension_ids.begin();
        ext_id != extension_ids.end(); ++ext_id) {
 
     // An extension's granted permissions need to be migrated if the
     // full_access bit is present. This bit was always present in the previous
     // scheme and is never present now.
@@ skipping 13 matching lines @@
 
       std::string granted_apis =
           JoinPrefs(kPrefGrantedPermissions, kPrefAPIs);
       if (ext->GetList(kPrefOldGrantedAPIs, &apis))
         new_apis = apis->DeepCopy();
       else
         new_apis = new ListValue();
 
       std::string plugin_name = info->GetByID(
           ExtensionAPIPermission::kPlugin)->name();
-      new_apis->Append(Value::CreateStringValue(plugin_name));
+      new_apis->Append(base::StringValue::New(plugin_name));
       UpdateExtensionPref(*ext_id, granted_apis, new_apis);
     }
 
     // The granted permissions originally only held the effective hosts,
     // which are a combination of host and user script host permissions.
     // We now maintain these lists separately. For migration purposes, it
     // does not matter how we treat the old effective hosts as long as the
     // new effective hosts will be the same, so we move them to explicit
     // host permissions.
     ListValue* hosts;
@@ skipping 46 matching lines @@
       extension_id, kPrefActivePermissions, permissions);
 }
 
 bool ExtensionPrefs::IsIncognitoEnabled(const std::string& extension_id) {
   return ReadExtensionPrefBoolean(extension_id, kPrefIncognitoEnabled);
 }
 
 void ExtensionPrefs::SetIsIncognitoEnabled(const std::string& extension_id,
                                            bool enabled) {
   UpdateExtensionPref(extension_id, kPrefIncognitoEnabled,
-                      Value::CreateBooleanValue(enabled));
+                      base::BooleanValue::New(enabled));
 }
 
 bool ExtensionPrefs::AllowFileAccess(const std::string& extension_id) {
   return ReadExtensionPrefBoolean(extension_id, kPrefAllowFileAccess);
 }
 
 void ExtensionPrefs::SetAllowFileAccess(const std::string& extension_id,
                                         bool allow) {
   UpdateExtensionPref(extension_id, kPrefAllowFileAccess,
-                      Value::CreateBooleanValue(allow));
+                      base::BooleanValue::New(allow));
 }
 
 bool ExtensionPrefs::HasAllowFileAccessSetting(
     const std::string& extension_id) const {
   const DictionaryValue* ext = GetExtensionPref(extension_id);
   return ext && ext->HasKey(kPrefAllowFileAccess);
 }
 
 ExtensionPrefs::LaunchType ExtensionPrefs::GetLaunchType(
     const std::string& extension_id,
@@ skipping 67 matching lines @@
     DLOG(FATAL) << "Failed to set a launch container.";
     result = extension_misc::LAUNCH_TAB;
   }
 
   return result;
 }
 
 void ExtensionPrefs::SetLaunchType(const std::string& extension_id,
                                    LaunchType launch_type) {
   UpdateExtensionPref(extension_id, kPrefLaunchType,
-      Value::CreateIntegerValue(static_cast<int>(launch_type)));
+      base::NumberValue::New(static_cast<int>(launch_type)));
 }
 
 bool ExtensionPrefs::DoesExtensionHaveState(
     const std::string& id, Extension::State check_state) const {
   const DictionaryValue* extension = GetExtensionPref(id);
   int state = -1;
   if (!extension || !extension->GetInteger(kPrefState, &state))
     return false;
 
   if (state < 0 || state >= Extension::NUM_STATES) {
@@ skipping 27 matching lines @@
   return extension_ids;
 }
 
 void ExtensionPrefs::SetToolbarOrder(
     const std::vector<std::string>& extension_ids) {
   ListPrefUpdate update(prefs_, kExtensionToolbar);
   ListValue* toolbar_order = update.Get();
   toolbar_order->Clear();
   for (std::vector<std::string>::const_iterator iter = extension_ids.begin();
        iter != extension_ids.end(); ++iter) {
-    toolbar_order->Append(new StringValue(*iter));
+    toolbar_order->Append(base::StringValue::New(*iter));
   }
   SavePrefs();
 }
 
 void ExtensionPrefs::OnExtensionInstalled(
     const Extension* extension,
     Extension::State initial_state,
     bool from_webstore) {
   const std::string& id = extension->id();
   CHECK(Extension::IdIsValid(id));
   ScopedExtensionPrefUpdate update(prefs_, id);
   DictionaryValue* extension_dict = update.Get();
   const base::Time install_time = GetCurrentTime();
-  extension_dict->Set(kPrefState, Value::CreateIntegerValue(initial_state));
+  extension_dict->Set(kPrefState, base::NumberValue::New(initial_state));
   extension_dict->Set(kPrefLocation,
-                      Value::CreateIntegerValue(extension->location()));
+                      base::NumberValue::New(extension->location()));
   extension_dict->Set(kPrefFromWebStore,
-                      Value::CreateBooleanValue(from_webstore));
+                      base::BooleanValue::New(from_webstore));
   extension_dict->Set(kPrefFromBookmark,
-                      Value::CreateBooleanValue(extension->from_bookmark()));
+                      base::BooleanValue::New(extension->from_bookmark()));
   extension_dict->Set(kPrefInstallTime,
-                      Value::CreateStringValue(
+                      base::StringValue::New(
                           base::Int64ToString(install_time.ToInternalValue())));
   extension_dict->Set(kPrefPreferences, new DictionaryValue());
   extension_dict->Set(kPrefIncognitoPreferences, new DictionaryValue());
   extension_dict->Set(kPrefContentSettings, new ListValue());
   extension_dict->Set(kPrefIncognitoContentSettings, new ListValue());
 
   FilePath::StringType path = MakePathRelative(install_directory_,
       extension->path());
-  extension_dict->Set(kPrefPath, Value::CreateStringValue(path));
+  extension_dict->Set(kPrefPath, base::StringValue::New(path));
   // We store prefs about LOAD extensions, but don't cache their manifest
   // since it may change on disk.
   if (extension->location() != Extension::LOAD) {
     extension_dict->Set(kPrefManifest,
                         extension->manifest_value()->DeepCopy());
   }
   extension_dict->Set(kPrefAppLaunchIndex,
-                      Value::CreateIntegerValue(GetNextAppLaunchIndex()));
+                      base::NumberValue::New(GetNextAppLaunchIndex()));
   extension_pref_value_map_->RegisterExtension(
       id, install_time, initial_state == Extension::ENABLED);
   content_settings_store_->RegisterExtension(
       id, install_time, initial_state == Extension::ENABLED);
 }
 
 void ExtensionPrefs::OnExtensionUninstalled(const std::string& extension_id,
                                             const Extension::Location& location,
                                             bool external_uninstall) {
   // For external extensions, we save a preference reminding ourself not to try
   // and install the extension anymore (except when |external_uninstall| is
   // true, which signifies that the registry key was deleted or the pref file
   // no longer lists the extension).
   if (!external_uninstall && Extension::IsExternalLocation(location)) {
     UpdateExtensionPref(extension_id, kPrefState,
-                        Value::CreateIntegerValue(
+                        base::NumberValue::New(
                             Extension::EXTERNAL_EXTENSION_UNINSTALLED));
     extension_pref_value_map_->SetExtensionState(extension_id, false);
     content_settings_store_->SetExtensionState(extension_id, false);
   } else {
     DeleteExtensionPrefs(extension_id);
   }
 }
 
 void ExtensionPrefs::SetExtensionState(const std::string& extension_id,
                                        Extension::State state) {
   UpdateExtensionPref(extension_id, kPrefState,
-                      Value::CreateIntegerValue(state));
+                      base::NumberValue::New(state));
   bool enabled = (state == Extension::ENABLED);
   extension_pref_value_map_->SetExtensionState(extension_id, enabled);
   content_settings_store_->SetExtensionState(extension_id, enabled);
 }
 
 bool ExtensionPrefs::GetBrowserActionVisibility(const Extension* extension) {
   const DictionaryValue* extension_prefs = GetExtensionPref(extension->id());
   if (!extension_prefs)
     return true;
   bool visible = false;
   if (!extension_prefs->GetBoolean(kBrowserActionVisible, &visible) || visible)
     return true;
 
   return false;
 }
 
 void ExtensionPrefs::SetBrowserActionVisibility(const Extension* extension,
                                                 bool visible) {
   if (GetBrowserActionVisibility(extension) == visible)
     return;
 
   UpdateExtensionPref(extension->id(), kBrowserActionVisible,
-                      Value::CreateBooleanValue(visible));
+                      base::BooleanValue::New(visible));
   NotificationService::current()->Notify(
       chrome::NOTIFICATION_EXTENSION_BROWSER_ACTION_VISIBILITY_CHANGED,
       Source<ExtensionPrefs>(this),
       Details<const Extension>(extension));
 }
 
 std::string ExtensionPrefs::GetVersionString(const std::string& extension_id) {
   const DictionaryValue* extension = GetExtensionPref(extension_id);
   if (!extension)
     return std::string();
@@ skipping 269 matching lines @@
   if (ReadExtensionPrefInteger(extension_id, kPrefAppLaunchIndex, &value))
     return value;
 
   return -1;
 }
 
 void ExtensionPrefs::SetAppLaunchIndex(const std::string& extension_id,
                                        int index) {
   DCHECK_GE(index, 0);
   UpdateExtensionPref(extension_id, kPrefAppLaunchIndex,
-                      Value::CreateIntegerValue(index));
+                      base::NumberValue::New(index));
 }
 
 int ExtensionPrefs::GetNextAppLaunchIndex() {
   const DictionaryValue* extensions = prefs_->GetDictionary(kExtensionsPref);
   if (!extensions)
     return 0;
 
   int max_value = -1;
   for (DictionaryValue::key_iterator extension_id = extensions->begin_keys();
        extension_id != extensions->end_keys(); ++extension_id) {
@@ skipping 17 matching lines @@
 
 int ExtensionPrefs::GetPageIndex(const std::string& extension_id) {
   int value = -1;
   ReadExtensionPrefInteger(extension_id, kPrefPageIndex, &value);
   return value;
 }
 
 void ExtensionPrefs::SetPageIndex(const std::string& extension_id, int index) {
   CHECK_GE(index, 0);
   UpdateExtensionPref(extension_id, kPrefPageIndex,
-                      Value::CreateIntegerValue(index));
+                      base::NumberValue::New(index));
 }
 
 bool ExtensionPrefs::WasAppDraggedByUser(const std::string& extension_id) {
   return ReadExtensionPrefBoolean(extension_id, kPrefUserDraggedApp);
 }
 
 void ExtensionPrefs::SetAppDraggedByUser(const std::string& extension_id) {
-  UpdateExtensionPref(extension_id, kPrefUserDraggedApp,
-                      Value::CreateBooleanValue(true));
+  UpdateExtensionPref(extension_id, kPrefUserDraggedApp, base::TrueValue());
 }
 
 void ExtensionPrefs::SetUpdateUrlData(const std::string& extension_id,
                                       const std::string& data) {
   UpdateExtensionPref(extension_id, kUpdateUrlData,
-                      Value::CreateStringValue(data));
+                      base::StringValue::New(data));
 }
 
 std::string ExtensionPrefs::GetUpdateUrlData(const std::string& extension_id) {
   const DictionaryValue* dictionary = GetExtensionPref(extension_id);
   if (!dictionary)
     return std::string();
 
   std::string data;
   dictionary->GetString(kUpdateUrlData, &data);
   return data;
@@ skipping 68 matching lines @@
   // Fix old entries that did not get an installation time entry when they
   // were installed or don't have a preferences field.
   for (ExtensionIdSet::const_iterator ext_id = extension_ids.begin();
        ext_id != extension_ids.end(); ++ext_id) {
     if (GetInstallTime(*ext_id) == base::Time()) {
       LOG(INFO) << "Could not parse installation time of extension "
                 << *ext_id << ". It was probably installed before setting "
                 << kPrefInstallTime << " was introduced. Updating "
                 << kPrefInstallTime << " to the current time.";
       const base::Time install_time = GetCurrentTime();
-      UpdateExtensionPref(*ext_id, kPrefInstallTime, Value::CreateStringValue(
+      UpdateExtensionPref(*ext_id, kPrefInstallTime, base::StringValue::New(
           base::Int64ToString(install_time.ToInternalValue())));
     }
   }
 }
 
 const DictionaryValue* ExtensionPrefs::GetExtensionControlledPrefs(
     const std::string& extension_id,
     bool incognito) const {
   std::string key = extension_id + std::string(".") +
       (incognito ? kPrefIncognitoPreferences : kPrefPreferences);
@@ skipping 192 matching lines @@
   prefs->RegisterListPref(prefs::kExtensionInstallAllowList,
                           PrefService::UNSYNCABLE_PREF);
   prefs->RegisterListPref(prefs::kExtensionInstallDenyList,
                           PrefService::UNSYNCABLE_PREF);
   prefs->RegisterListPref(prefs::kExtensionInstallForceList,
                           PrefService::UNSYNCABLE_PREF);
   prefs->RegisterStringPref(kWebStoreLogin,
                             std::string() /* default_value */,
                             PrefService::UNSYNCABLE_PREF);
 }