Fix a bug where Guest Profiles in CrOS could cause crashes when collecting

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 "chrome/browser/content_settings/content_settings_utils.h"
 #include "chrome/browser/content_settings/host_content_settings_map.h"
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/profiles/profile.h"
@@ skipping 92 matching lines @@
       {"storageTabLabel", IDS_WEBSITE_SETTINGS_TYPE_STORAGE},
       {"batteryTabLabel", IDS_WEBSITE_SETTINGS_TYPE_BATTERY},
   };
 
   RegisterStrings(localized_strings, resources, arraysize(resources));
   RegisterTitle(
       localized_strings, "websiteSettingsPage", IDS_WEBSITE_SETTINGS_TITLE);
 }
 
 void WebsiteSettingsHandler::InitializeHandler() {
-  Profile* profile = Profile::FromWebUI(web_ui());
+  Profile* profile = GetProfile();
   HostContentSettingsMap* settings = profile->GetHostContentSettingsMap();
   observer_.Add(settings);
 
   power::OriginPowerMap* origin_power_map =
       power::OriginPowerMapFactory::GetForBrowserContext(profile);
   // OriginPowerMap may not be available in tests.
   if (origin_power_map) {
     subscription_ = origin_power_map->AddPowerConsumptionUpdatedCallback(
         base::Bind(&WebsiteSettingsHandler::Update, base::Unretained(this)));
   }
@@ skipping 97 matching lines @@
     const base::ListValue* args) {
   bool rv = args->GetString(0, &last_filter_);
   DCHECK(rv);
 
   Update();
 }
 
 void WebsiteSettingsHandler::HandleUpdateLocalStorage(
     const base::ListValue* args) {
   if (!local_storage_.get()) {
-    Profile* profile = Profile::FromWebUI(web_ui());
+    Profile* profile = GetProfile();
     local_storage_ = new BrowsingDataLocalStorageHelper(profile);
   }
 
   last_setting_ = kStorage;
 
   local_storage_->StartFetching(
       base::Bind(&WebsiteSettingsHandler::OnLocalStorageFetched,
                  weak_ptr_factory_.GetWeakPtr()));
 }
 
@@ skipping 24 matching lines @@
   DCHECK(!last_setting_.empty());
   if (last_setting_ == kStorage)
     UpdateLocalStorage();
   else if (last_setting_ == kBattery)
     UpdateBatteryUsage();
   else
     UpdateOrigins();
 }
 
 void WebsiteSettingsHandler::UpdateOrigins() {
-  Profile* profile = Profile::FromWebUI(web_ui());
+  Profile* profile = GetProfile();
   HostContentSettingsMap* settings = profile->GetHostContentSettingsMap();
 
   ContentSettingsForOneType all_settings;
   ContentSettingsType last_setting;
   content_settings::GetTypeFromName(last_setting_, &last_setting);
 
   if (last_setting == CONTENT_SETTINGS_TYPE_MEDIASTREAM)
     last_setting = CONTENT_SETTINGS_TYPE_MEDIASTREAM_MIC;
 
   settings->GetSettingsForOneType(last_setting, std::string(), &all_settings);
@@ skipping 85 matching lines @@
   DCHECK(rv);
   ContentSettingsType settings_type;
   rv = content_settings::GetTypeFromName(setting_name, &settings_type);
   DCHECK(rv);
 
   std::string value;
   rv = args->GetString(1, &value);
   DCHECK(rv);
 
   ContentSetting setting = content_settings::ContentSettingFromString(value);
-  Profile* profile = Profile::FromWebUI(web_ui());
+  Profile* profile = GetProfile();
   HostContentSettingsMap* map = profile->GetHostContentSettingsMap();
   ContentSetting default_value =
       map->GetDefaultContentSetting(settings_type, NULL);
 
   // Users are not allowed to be the source of the "ask" setting. It is an
   // ephemeral setting which is removed once the question is asked.
   if (setting == CONTENT_SETTING_ASK && setting == default_value)
     setting = CONTENT_SETTING_DEFAULT;
 
   ContentSettingsPattern primary_pattern;
@@ skipping 83 matching lines @@
   std::string setting;
   if (!args->GetString(0, &setting)) {
     NOTREACHED();
     return;
   }
   ContentSetting new_default =
       content_settings::ContentSettingFromString(setting);
 
   ContentSettingsType last_setting;
   content_settings::GetTypeFromName(last_setting_, &last_setting);
-  Profile* profile = Profile::FromWebUI(web_ui());
-
-#if defined(OS_CHROMEOS)
-  // ChromeOS 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
+  Profile* profile = GetProfile();
 
   HostContentSettingsMap* map = profile->GetHostContentSettingsMap();
   map->SetDefaultContentSetting(last_setting, new_default);
 
   switch (last_setting) {
     case CONTENT_SETTINGS_TYPE_AUTOMATIC_DOWNLOADS:
       content::RecordAction(
           UserMetricsAction("Options_DefaultMultipleAutomaticDLSettingChange"));
       break;
     case CONTENT_SETTINGS_TYPE_COOKIES:
@@ skipping 38 matching lines @@
     const base::ListValue* args) {
   DCHECK_EQ(1U, args->GetSize());
   bool is_enabled;
   bool rv = args->GetBoolean(0, &is_enabled);
   DCHECK(rv);
 
   ContentSettingsType last_setting;
   rv = content_settings::GetTypeFromName(last_setting_, &last_setting);
   DCHECK(rv);
 
-  Profile* profile = Profile::FromWebUI(web_ui());
+  Profile* profile = GetProfile();
   HostContentSettingsMap* map = profile->GetHostContentSettingsMap();
   map->SetContentSettingOverride(last_setting, is_enabled);
 }
 
 void WebsiteSettingsHandler::GetInfoForOrigin(const GURL& site_url,
                                               bool show_page) {
-  Profile* profile = Profile::FromWebUI(web_ui());
+  Profile* profile = GetProfile();
   HostContentSettingsMap* map = profile->GetHostContentSettingsMap();
 
   double storage = 0.0;
   for (LocalStorageList::const_iterator it = local_storage_list_.begin();
        it != local_storage_list_.end();
        it++) {
     if (it->origin_url == site_url) {
       storage = static_cast<double>(it->size);
       break;
     }
   }
 
   int battery = 0;
   battery = OriginPowerMapFactory::GetForBrowserContext(
-      Profile::FromWebUI(web_ui()))->GetPowerForOrigin(site_url);
+      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;
     ContentSetting default_value =
         map->GetDefaultContentSetting(permission_type, NULL);
     if (default_value != CONTENT_SETTING_ALLOW &&
@@ skipping 79 matching lines @@
         "readableName", GetReadableName(it->origin_url));
     local_storage_map.SetWithoutPathExpansion(origin, origin_entry);
   }
   web_ui()->CallJavascriptFunction("WebsiteSettingsManager.populateOrigins",
                                    local_storage_map);
 }
 
 void WebsiteSettingsHandler::UpdateBatteryUsage() {
   base::DictionaryValue power_map;
   OriginPowerMap* origins =
-      OriginPowerMapFactory::GetForBrowserContext(Profile::FromWebUI(web_ui()));
+      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();
     origin_entry->SetInteger("usage", it->second);
     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);
   }
   web_ui()->CallJavascriptFunction("WebsiteSettingsManager.populateOrigins",
                                    power_map);
 }
 
 std::string WebsiteSettingsHandler::GetSettingDefaultFromModel(
     ContentSettingsType type,
     std::string* provider_id) {
-  Profile* profile = Profile::FromWebUI(web_ui());
+  Profile* profile = GetProfile();
   ContentSetting default_setting =
       profile->GetHostContentSettingsMap()->GetDefaultContentSetting(
           type, provider_id);
 
   return content_settings::ContentSettingToString(default_setting);
 }
 
 void WebsiteSettingsHandler::StopOrigin(const GURL& site_url) {
-  Profile* profile = Profile::FromWebUI(web_ui());
+  Profile* profile = GetProfile();
   if (site_url.SchemeIs(extensions::kExtensionScheme)) {
     const extensions::Extension* extension =
         extensions::ExtensionRegistry::Get(profile)
             ->enabled_extensions()
             .GetHostedAppByURL(site_url);
     if (extension) {
       extensions::AppWindowRegistry::Get(profile)
           ->CloseAllAppWindowsForApp(extension->id());
     }
   }
@@ skipping 12 matching lines @@
           profile !=
               Profile::FromBrowserContext(web_contents->GetBrowserContext())) {
         continue;
       }
       model->DiscardWebContentsAt(idx);
     }
   }
 }
 
 void WebsiteSettingsHandler::DeleteLocalStorage(const GURL& site_url) {
-  Profile* profile = Profile::FromWebUI(web_ui());
+  Profile* profile = GetProfile();
   content::DOMStorageContext* dom_storage_context_ =
       content::BrowserContext::GetDefaultStoragePartition(profile)
           ->GetDOMStorageContext();
   dom_storage_context_->DeleteLocalStorage(site_url);
 
   // Load a new BrowsingDataLocalStorageHelper to update.
   local_storage_ = new BrowsingDataLocalStorageHelper(profile);
 
   local_storage_->StartFetching(
       base::Bind(&WebsiteSettingsHandler::OnLocalStorageFetched,
                  weak_ptr_factory_.GetWeakPtr()));
 }
 
 const std::string& WebsiteSettingsHandler::GetReadableName(
     const GURL& site_url) {
   if (site_url.SchemeIs(extensions::kExtensionScheme)) {
-    Profile* profile = Profile::FromWebUI(web_ui());
+    Profile* profile = GetProfile();
     ExtensionService* extension_service =
         extensions::ExtensionSystem::Get(profile)->extension_service();
 
     const extensions::Extension* extension =
         extension_service->extensions()->GetExtensionOrAppByURL(site_url);
     // If extension is NULL, it was removed and we cannot look up its name.
     if (!extension)
       return site_url.spec();
 
     return extension->name();
   }
   return site_url.spec();
 }
 
+Profile* WebsiteSettingsHandler::GetProfile() {
+  Profile* profile = Profile::FromWebUI(web_ui());
+#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