Add DictionaryValue::Set and ::SetWithoutPathExpansion fns

chrome/browser/ui/webui/options/website_settings_handler.cc

 // Copyright 2014 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/ui/webui/options/website_settings_handler.h"
 
 #include "base/metrics/histogram.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/browser_iterator.h"
@@ skipping 364 matching lines @@
       if (it->setting != cam_setting)
         continue;
     }
 
     if (origin.find(last_filter_) == base::string16::npos)
       continue;
 
     base::Time last_usage = settings->GetLastUsageByPattern(
         it->primary_pattern, it->secondary_pattern, last_setting);
 
-    base::DictionaryValue* origin_entry = new base::DictionaryValue();
+    scoped_ptr<base::DictionaryValue> origin_entry(new base::DictionaryValue());
     origin_entry->SetDoubleWithoutPathExpansion("usage",
                                                 last_usage.ToDoubleT());
     base::string16 usage_string;
     if (last_usage.ToDoubleT()) {
       usage_string = ui::TimeFormat::Simple(ui::TimeFormat::FORMAT_ELAPSED,
                                             ui::TimeFormat::LENGTH_SHORT,
                                             base::Time::Now() - last_usage);
     }
     origin_entry->SetStringWithoutPathExpansion("usageString", usage_string);
     origin_entry->SetStringWithoutPathExpansion("readableName",
                                                 GetReadableName(origin_url));
 
     if (it->setting == CONTENT_SETTING_BLOCK)
-      blocked_origins.SetWithoutPathExpansion(origin, origin_entry);
+      blocked_origins.SetWithoutPathExpansion(origin, origin_entry.Pass());
     else
-      allowed_origins.SetWithoutPathExpansion(origin, origin_entry);
+      allowed_origins.SetWithoutPathExpansion(origin, origin_entry.Pass());
   }
 
   bool is_globally_allowed = settings->GetContentSettingOverride(last_setting);
   web_ui()->CallJavascriptFunction("WebsiteSettingsManager.populateOrigins",
                                    allowed_origins,
                                    blocked_origins,
                                    base::FundamentalValue(is_globally_allowed));
 }
 
 void WebsiteSettingsHandler::HandleGetOriginInfo(const base::ListValue* args) {
@@ skipping 212 matching lines @@
 
   int battery = 0;
   battery = OriginPowerMapFactory::GetForBrowserContext(
       GetProfile())->GetPowerForOrigin(site_url);
 
   base::DictionaryValue* permissions = new base::DictionaryValue;
   for (size_t i = 0; i < arraysize(kValidTypes); ++i) {
     ContentSettingsType permission_type = kValidTypes[i];
 
     // Append the possible settings.
-    base::ListValue* options = new base::ListValue;
+    scoped_ptr<base::ListValue> options(new base::ListValue());
     ContentSetting default_value =
         map->GetDefaultContentSetting(permission_type, NULL);
     if (default_value != CONTENT_SETTING_ALLOW &&
         default_value != CONTENT_SETTING_BLOCK) {
       options->AppendString(
           content_settings::ContentSettingToString(default_value));
     }
     options->AppendString(
         content_settings::ContentSettingToString(CONTENT_SETTING_ALLOW));
     options->AppendString(
@@ skipping 23 matching lines @@
       if (mic_setting != cam_setting)
         permission = CONTENT_SETTING_ASK;
       else
         permission = mic_setting;
     } else {
       scoped_ptr<base::Value> v(map->GetWebsiteSettingWithoutOverride(
           site_url, site_url, permission_type, std::string(), &info));
       permission = content_settings::ValueToContentSetting(v.get());
     }
 
-    base::DictionaryValue* permission_info = new base::DictionaryValue;
+    scoped_ptr<base::DictionaryValue>
+        permission_info(new base::DictionaryValue());
     permission_info->SetStringWithoutPathExpansion(
         "setting", content_settings::ContentSettingToString(permission));
-    permission_info->SetWithoutPathExpansion("options", options);
+    permission_info->SetWithoutPathExpansion("options", options.Pass());
     permission_info->SetBooleanWithoutPathExpansion(
         "editable", info.source == content_settings::SETTING_SOURCE_USER);
     permissions->SetWithoutPathExpansion(
-        content_settings::GetTypeName(permission_type), permission_info);
+        content_settings::GetTypeName(permission_type), permission_info.Pass());
   }
 
   base::Value* storage_used = new base::StringValue(l10n_util::GetStringFUTF16(
       IDS_WEBSITE_SETTINGS_STORAGE_USED, ui::FormatBytes(storage)));
   base::Value* battery_used =
       new base::StringValue(l10n_util::GetStringFUTF16Int(
           IDS_WEBSITE_SETTINGS_BATTERY_USED, battery));
 
   web_ui()->CallJavascriptFunction("WebsiteSettingsEditor.populateOrigin",
                                    *storage_used,
                                    *battery_used,
                                    *permissions,
                                    base::FundamentalValue(show_page));
 }
 
 void WebsiteSettingsHandler::UpdateLocalStorage() {
   base::DictionaryValue local_storage_map;
   for (LocalStorageList::const_iterator it = local_storage_list_.begin();
        it != local_storage_list_.end();
        it++) {
     std::string origin = it->origin_url.spec();
 
     if (origin.find(last_filter_) == base::string16::npos)
       continue;
 
-    base::DictionaryValue* origin_entry = new base::DictionaryValue();
-    origin_entry->SetWithoutPathExpansion(
-        "usage", new base::FundamentalValue(static_cast<double>(it->size)));
-    origin_entry->SetWithoutPathExpansion(
-        "usageString", new base::StringValue(ui::FormatBytes(it->size)));
+    scoped_ptr<base::DictionaryValue> origin_entry(new base::DictionaryValue());
+    origin_entry->SetDoubleWithoutPathExpansion(
+        "usage", static_cast<double>(it->size));
+    origin_entry->SetStringWithoutPathExpansion(
+        "usageString", ui::FormatBytes(it->size));
     origin_entry->SetStringWithoutPathExpansion(
         "readableName", GetReadableName(it->origin_url));
-    local_storage_map.SetWithoutPathExpansion(origin, origin_entry);
+    local_storage_map.SetWithoutPathExpansion(origin, origin_entry.Pass());
   }
   web_ui()->CallJavascriptFunction("WebsiteSettingsManager.populateOrigins",
                                    local_storage_map);
 }
 
 void WebsiteSettingsHandler::UpdateBatteryUsage() {
   base::DictionaryValue power_map;
   OriginPowerMap* origins =
       OriginPowerMapFactory::GetForBrowserContext(GetProfile());
   OriginPowerMap::PercentOriginMap percent_map = origins->GetPercentOriginMap();
   for (std::map<GURL, int>::iterator it = percent_map.begin();
        it != percent_map.end();
        ++it) {
     std::string origin = it->first.spec();
 
     if (origin.find(last_filter_) == base::string16::npos)
       continue;
 
-    base::DictionaryValue* origin_entry = new base::DictionaryValue();
+    scoped_ptr<base::DictionaryValue> origin_entry(new base::DictionaryValue());
     origin_entry->SetInteger("usage", it->second);
     if (it->second == 0) {
       origin_entry->SetString(
           "usageString",
           l10n_util::GetStringUTF16(IDS_WEBSITE_SETTINGS_BATTERY_ZERO_PERCENT));
     } else {
       origin_entry->SetString(
           "usageString",
           l10n_util::GetStringFUTF16Int(IDS_WEBSITE_SETTINGS_BATTERY_PERCENT,
                                         it->second));
     }
     origin_entry->SetStringWithoutPathExpansion("readableName",
                                                 GetReadableName(it->first));
-    power_map.SetWithoutPathExpansion(origin, origin_entry);
+    power_map.SetWithoutPathExpansion(origin, origin_entry.Pass());
   }
   web_ui()->CallJavascriptFunction("WebsiteSettingsManager.populateOrigins",
                                    power_map);
 }
 
 void WebsiteSettingsHandler::StopOrigin(const GURL& site_url) {
   Profile* profile = GetProfile();
   if (site_url.SchemeIs(extensions::kExtensionScheme)) {
     const extensions::Extension* extension =
         extensions::ExtensionRegistry::Get(profile)
@@ skipping 61 matching lines @@
 #if defined(OS_CHROMEOS)
   // Chrome OS special case: in Guest mode settings are opened in Incognito
   // mode, so we need original profile to actually modify settings.
   if (user_manager::UserManager::Get()->IsLoggedInAsGuest())
     profile = profile->GetOriginalProfile();
 #endif
   return profile;
 }
 
 }  // namespace options