c/b/extensions, json_schema_compiler: Do not use Value::Create*.

chrome/browser/extensions/extension_prefs.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/extension_prefs.h"
 
 #include "base/prefs/pref_notifier.h"
 #include "base/prefs/pref_service.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
@@ skipping 563 matching lines @@
   APIPermissionSet apis = new_value->apis();
   std::string api_pref = JoinPrefs(pref_key, kPrefAPIs);
   for (APIPermissionSet::const_iterator i = apis.begin();
        i != apis.end(); ++i) {
     scoped_ptr<Value> detail(i->ToValue());
     if (detail) {
       DictionaryValue* tmp = new DictionaryValue();
       tmp->Set(i->name(), detail.release());
       api_values->Append(tmp);
     } else {
-      api_values->Append(Value::CreateStringValue(i->name()));
+      api_values->Append(new base::StringValue(i->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());
   }
 
   // Set the scriptable host permissions.
   if (!new_value->scriptable_hosts().is_empty()) {
     SetExtensionPrefURLPatternSet(extension_id,
                                   JoinPrefs(pref_key, kPrefScriptableHosts),
                                   new_value->scriptable_hosts());
   }
 }
 
 int ExtensionPrefs::IncrementAcknowledgePromptCount(
     const std::string& extension_id) {
   int count = 0;
   ReadPrefAsInteger(extension_id, kPrefAcknowledgePromptCount, &count);
   ++count;
   UpdateExtensionPref(extension_id, kPrefAcknowledgePromptCount,
-                      Value::CreateIntegerValue(count));
+                      new base::FundamentalValue(count));
   return count;
 }
 
 bool ExtensionPrefs::IsExternalExtensionAcknowledged(
     const std::string& extension_id) {
   return ReadPrefAsBooleanAndReturn(extension_id, kPrefExternalAcknowledged);
 }
 
 void ExtensionPrefs::AcknowledgeExternalExtension(
     const std::string& extension_id) {
   DCHECK(Extension::IdIsValid(extension_id));
   UpdateExtensionPref(extension_id, kPrefExternalAcknowledged,
-                      Value::CreateBooleanValue(true));
+                      new base::FundamentalValue(true));
   UpdateExtensionPref(extension_id, kPrefAcknowledgePromptCount, NULL);
 }
 
 bool ExtensionPrefs::IsBlacklistedExtensionAcknowledged(
     const std::string& extension_id) {
   return ReadPrefAsBooleanAndReturn(extension_id, kPrefBlacklistAcknowledged);
 }
 
 void ExtensionPrefs::AcknowledgeBlacklistedExtension(
     const std::string& extension_id) {
   DCHECK(Extension::IdIsValid(extension_id));
   UpdateExtensionPref(extension_id, kPrefBlacklistAcknowledged,
-                      Value::CreateBooleanValue(true));
+                      new base::FundamentalValue(true));
   UpdateExtensionPref(extension_id, kPrefAcknowledgePromptCount, NULL);
 }
 
 bool ExtensionPrefs::IsExternalInstallFirstRun(
     const std::string& extension_id) {
   return ReadPrefAsBooleanAndReturn(extension_id, kPrefExternalInstallFirstRun);
 }
 
 void ExtensionPrefs::SetExternalInstallFirstRun(
     const std::string& extension_id) {
   DCHECK(Extension::IdIsValid(extension_id));
   UpdateExtensionPref(extension_id, kPrefExternalInstallFirstRun,
-                      Value::CreateBooleanValue(true));
+                      new base::FundamentalValue(true));
 }
 
 bool ExtensionPrefs::SetAlertSystemFirstRun() {
   if (prefs_->GetBoolean(prefs::kExtensionAlertsInitializedPref)) {
     return true;
   }
   prefs_->SetBoolean(prefs::kExtensionAlertsInitializedPref, true);
   return false;
 }
 
 bool ExtensionPrefs::ExtensionsBlacklistedByDefault() const {
   return admin_policy::BlacklistedByDefault(
       prefs_->GetList(prefs::kExtensionInstallDenyList));
 }
 
 bool ExtensionPrefs::DidExtensionEscalatePermissions(
     const std::string& extension_id) {
   return ReadPrefAsBooleanAndReturn(extension_id,
                                     kExtensionDidEscalatePermissions);
 }
 
 void ExtensionPrefs::SetDidExtensionEscalatePermissions(
     const Extension* extension, bool did_escalate) {
   UpdateExtensionPref(extension->id(), kExtensionDidEscalatePermissions,
-                      Value::CreateBooleanValue(did_escalate));
+                      new base::FundamentalValue(did_escalate));
 }
 
 int ExtensionPrefs::GetDisableReasons(const std::string& extension_id) {
   int value = -1;
   if (ReadPrefAsInteger(extension_id, kPrefDisableReasons, &value) &&
       value >= 0) {
     return value;
   }
   return Extension::DISABLE_NONE;
 }
 
 void ExtensionPrefs::AddDisableReason(const std::string& extension_id,
                                       Extension::DisableReason disable_reason) {
   int new_value = GetDisableReasons(extension_id) |
       static_cast<int>(disable_reason);
   UpdateExtensionPref(extension_id, kPrefDisableReasons,
-                      Value::CreateIntegerValue(new_value));
+                      new base::FundamentalValue(new_value));
 }
 
 void ExtensionPrefs::RemoveDisableReason(
     const std::string& extension_id,
     Extension::DisableReason disable_reason) {
   int new_value = GetDisableReasons(extension_id) &
       ~static_cast<int>(disable_reason);
   if (new_value == Extension::DISABLE_NONE) {
     UpdateExtensionPref(extension_id, kPrefDisableReasons, NULL);
   } else {
     UpdateExtensionPref(extension_id, kPrefDisableReasons,
-                        Value::CreateIntegerValue(new_value));
+                        new base::FundamentalValue(new_value));
   }
 }
 
 void ExtensionPrefs::ClearDisableReasons(const std::string& extension_id) {
   UpdateExtensionPref(extension_id, kPrefDisableReasons, NULL);
 }
 
 std::set<std::string> ExtensionPrefs::GetBlacklistedExtensions() {
   std::set<std::string> ids;
 
@@ skipping 111 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));
+                      new base::FundamentalValue(active));
 }
 
 void ExtensionPrefs::MigratePermissions(const ExtensionIdList& extension_ids) {
   PermissionsInfo* info = PermissionsInfo::GetInstance();
   for (ExtensionIdList::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(
           APIPermission::kPlugin)->name();
-      new_apis->Append(Value::CreateStringValue(plugin_name));
+      new_apis->Append(new base::StringValue(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.
     const ListValue* hosts = NULL;
@@ skipping 22 matching lines @@
           break;
         case Extension::DEPRECATED_DISABLE_PERMISSIONS_INCREASE:
           new_value = Extension::DISABLE_PERMISSIONS_INCREASE;
           break;
         case Extension::DEPRECATED_DISABLE_RELOAD:
           new_value = Extension::DISABLE_RELOAD;
           break;
       }
 
       UpdateExtensionPref(*ext_id, kPrefDisableReasons,
-                          Value::CreateIntegerValue(new_value));
+                          new base::FundamentalValue(new_value));
       // Remove the old disable reason.
       UpdateExtensionPref(*ext_id, kDeprecatedPrefDisableReason, NULL);
     }
   }
 }
 
 PermissionSet* ExtensionPrefs::GetGrantedPermissions(
     const std::string& extension_id) {
   CHECK(Extension::IdIsValid(extension_id));
   return ReadPrefAsPermissionSet(extension_id, kPrefGrantedPermissions);
@@ skipping 43 matching lines @@
 
 void ExtensionPrefs::SetActivePermissions(
     const std::string& extension_id,
     const PermissionSet* permissions) {
   SetExtensionPrefPermissionSet(
       extension_id, kPrefActivePermissions, permissions);
 }
 
 void ExtensionPrefs::SetExtensionRunning(const std::string& extension_id,
     bool is_running) {
-  Value* value = Value::CreateBooleanValue(is_running);
+  Value* value = new base::FundamentalValue(is_running);
   UpdateExtensionPref(extension_id, kPrefRunning, value);
 }
 
 bool ExtensionPrefs::IsExtensionRunning(const std::string& extension_id) {
   const DictionaryValue* extension = GetExtensionPref(extension_id);
   if (!extension)
     return false;
   bool running = false;
   extension->GetBoolean(kPrefRunning, &running);
   return running;
 }
 
 void ExtensionPrefs::SetIsActive(const std::string& extension_id,
                                  bool is_active) {
-  Value* value = Value::CreateBooleanValue(is_active);
+  Value* value = new base::FundamentalValue(is_active);
   UpdateExtensionPref(extension_id, kIsActive, value);
 }
 
 bool ExtensionPrefs::IsActive(const std::string& extension_id) {
   const DictionaryValue* extension = GetExtensionPref(extension_id);
   if (!extension)
     return false;
   bool is_active = false;
   extension->GetBoolean(kIsActive, &is_active);
   return is_active;
 }
 
 bool ExtensionPrefs::IsIncognitoEnabled(const std::string& extension_id) {
   return ReadPrefAsBooleanAndReturn(extension_id, kPrefIncognitoEnabled);
 }
 
 void ExtensionPrefs::SetIsIncognitoEnabled(const std::string& extension_id,
                                            bool enabled) {
   UpdateExtensionPref(extension_id, kPrefIncognitoEnabled,
-                      Value::CreateBooleanValue(enabled));
+                      new base::FundamentalValue(enabled));
 }
 
 bool ExtensionPrefs::AllowFileAccess(const std::string& extension_id) {
   return ReadPrefAsBooleanAndReturn(extension_id, kPrefAllowFileAccess);
 }
 
 void ExtensionPrefs::SetAllowFileAccess(const std::string& extension_id,
                                         bool allow) {
   UpdateExtensionPref(extension_id, kPrefAllowFileAccess,
-                      Value::CreateBooleanValue(allow));
+                      new base::FundamentalValue(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 Extension* extension,
@@ skipping 85 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)));
+      new base::FundamentalValue(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 41 matching lines @@
                                             const Manifest::Location& location,
                                             bool external_uninstall) {
   extension_sorting_->ClearOrdinals(extension_id);
 
   // 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 && Manifest::IsExternalLocation(location)) {
     UpdateExtensionPref(extension_id, kPrefState,
-                        Value::CreateIntegerValue(
+                        new base::FundamentalValue(
                             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));
+                      new base::FundamentalValue(state));
   bool enabled = (state == Extension::ENABLED);
   extension_pref_value_map_->SetExtensionState(extension_id, enabled);
   content_settings_store_->SetExtensionState(extension_id, enabled);
 }
 
 std::string ExtensionPrefs::GetVersionString(const std::string& extension_id) {
   const DictionaryValue* extension = GetExtensionPref(extension_id);
   if (!extension)
     return std::string();
 
@@ skipping 169 matching lines @@
                                       &serialized_ordinal)) {
     suggested_page_ordinal = syncer::StringOrdinal(serialized_ordinal);
     needs_sort_ordinal = true;
     pending_install_dict->Remove(kPrefSuggestedPageOrdinal, NULL);
   }
   pending_install_dict->Remove(kDelayedInstallReason, NULL);
 
   const base::Time install_time = time_provider_->GetCurrentTime();
   pending_install_dict->Set(
       kPrefInstallTime,
-      Value::CreateStringValue(
+      new base::StringValue(
           base::Int64ToString(install_time.ToInternalValue())));
 
   // Commit the delayed install data.
   extension_dict->MergeDictionary(pending_install_dict);
   FinishExtensionInfoPrefs(extension_id, install_time, needs_sort_ordinal,
                            suggested_page_ordinal, extension_dict);
   return true;
 }
 
 scoped_ptr<ExtensionInfo> ExtensionPrefs::GetDelayedInstallInfo(
@@ skipping 45 matching lines @@
 
   return extensions_info.Pass();
 }
 
 bool ExtensionPrefs::WasAppDraggedByUser(const std::string& extension_id) {
   return ReadPrefAsBooleanAndReturn(extension_id, kPrefUserDraggedApp);
 }
 
 void ExtensionPrefs::SetAppDraggedByUser(const std::string& extension_id) {
   UpdateExtensionPref(extension_id, kPrefUserDraggedApp,
-                      Value::CreateBooleanValue(true));
+                      new base::FundamentalValue(true));
 }
 
 bool ExtensionPrefs::IsFromWebStore(
     const std::string& extension_id) const {
   const DictionaryValue* dictionary = GetExtensionPref(extension_id);
   bool result = false;
   if (dictionary && dictionary->GetBoolean(kPrefFromWebStore, &result))
     return result;
   return false;
 }
@@ skipping 101 matching lines @@
   for (ExtensionIdList::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 = time_provider_->GetCurrentTime();
       UpdateExtensionPref(*ext_id,
                           kPrefInstallTime,
-                          Value::CreateStringValue(base::Int64ToString(
+                          new base::StringValue(base::Int64ToString(
                               install_time.ToInternalValue())));
     }
   }
 }
 
 void ExtensionPrefs::InitPrefStore() {
   if (extensions_disabled_) {
     extension_pref_value_map_->NotifyInitializationCompleted();
     return;
   }
@@ skipping 164 matching lines @@
 }
 
 void ExtensionPrefs::SetExtensionPrefFromVector(
     const char* pref,
     const ExtensionIdList& strings) {
   ListPrefUpdate update(prefs_, pref);
   ListValue* list_of_values = update.Get();
   list_of_values->Clear();
   for (ExtensionIdList::const_iterator iter = strings.begin();
        iter != strings.end(); ++iter)
-    list_of_values->Append(new StringValue(*iter));
+    list_of_values->Append(new base::StringValue(*iter));
 }
 
 void ExtensionPrefs::PopulateExtensionInfoPrefs(
     const Extension* extension,
     const base::Time install_time,
     Extension::State initial_state,
     Blacklist::BlacklistState blacklist_state,
     DictionaryValue* extension_dict) {
   // Leave the state blank for component extensions so that old chrome versions
   // loading new profiles do not fail in GetInstalledExtensionInfo. Older
   // Chrome versions would only check for an omitted state.
   if (initial_state != Extension::ENABLED_COMPONENT)
-    extension_dict->Set(kPrefState, Value::CreateIntegerValue(initial_state));
+    extension_dict->Set(kPrefState, new base::FundamentalValue(initial_state));
 
   extension_dict->Set(kPrefLocation,
-                      Value::CreateIntegerValue(extension->location()));
+                      new base::FundamentalValue(extension->location()));
   extension_dict->Set(kPrefCreationFlags,
-                      Value::CreateIntegerValue(extension->creation_flags()));
+                      new base::FundamentalValue(extension->creation_flags()));
   extension_dict->Set(kPrefFromWebStore,
-                      Value::CreateBooleanValue(extension->from_webstore()));
+                      new base::FundamentalValue(extension->from_webstore()));
   extension_dict->Set(kPrefFromBookmark,
-                      Value::CreateBooleanValue(extension->from_bookmark()));
+                      new base::FundamentalValue(extension->from_bookmark()));
   extension_dict->Set(
       kPrefWasInstalledByDefault,
-      Value::CreateBooleanValue(extension->was_installed_by_default()));
+      new base::FundamentalValue(extension->was_installed_by_default()));
   extension_dict->Set(kPrefInstallTime,
-                      Value::CreateStringValue(
+                      new base::StringValue(
                           base::Int64ToString(install_time.ToInternalValue())));
   if (blacklist_state == Blacklist::BLACKLISTED)
-    extension_dict->Set(kPrefBlacklist, Value::CreateBooleanValue(true));
+    extension_dict->Set(kPrefBlacklist, new base::FundamentalValue(true));
 
   base::FilePath::StringType path = MakePathRelative(install_directory_,
                                                      extension->path());
-  extension_dict->Set(kPrefPath, Value::CreateStringValue(path));
+  extension_dict->Set(kPrefPath, new base::StringValue(path));
   // We store prefs about LOAD extensions, but don't cache their manifest
   // since it may change on disk.
   if (!Manifest::IsUnpackedLocation(extension->location())) {
     extension_dict->Set(kPrefManifest,
                         extension->manifest()->value()->DeepCopy());
   }
 }
 
 void ExtensionPrefs::FinishExtensionInfoPrefs(
     const std::string& extension_id,
@@ skipping 33 matching lines @@
     is_enabled = initial_state == Extension::ENABLED;
   }
 
   extension_pref_value_map_->RegisterExtension(extension_id, install_time,
                                                is_enabled);
   content_settings_store_->RegisterExtension(extension_id, install_time,
                                              is_enabled);
 }
 
 }  // namespace extensions