Migrate geolocation settings to host content settings map.

chrome/browser/ui/webui/options/content_settings_handler.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/ui/webui/options/content_settings_handler.h"
 
+#include <map>
 #include <string>
 #include <vector>
 
 #include "base/callback.h"
 #include "base/command_line.h"
 #include "base/utf_string_conversions.h"
 #include "base/values.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/content_settings/content_settings_details.h"
+#include "chrome/browser/content_settings/content_settings_pattern.h"
 #include "chrome/browser/content_settings/content_settings_utils.h"
 #include "chrome/browser/content_settings/host_content_settings_map.h"
 #include "chrome/browser/custom_handlers/protocol_handler_registry.h"
-#include "chrome/browser/geolocation/geolocation_content_settings_map.h"
 #include "chrome/browser/notifications/desktop_notification_service.h"
 #include "chrome/browser/notifications/desktop_notification_service_factory.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/ui/browser_list.h"
 #include "chrome/common/chrome_notification_types.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/content_settings_helper.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/common/url_constants.h"
 #include "content/common/content_notification_types.h"
 #include "content/common/notification_service.h"
 #include "content/common/notification_source.h"
 #include "grit/generated_resources.h"
 #include "grit/locale_settings.h"
 #include "ui/base/l10n/l10n_util.h"
 
 namespace {
 
 struct ContentSettingsTypeNameEntry {
   ContentSettingsType type;
   const char* name;
 };
 
+typedef std::map<ContentSettingsPattern, ContentSetting> OnePatternSettings;
+typedef std::map<ContentSettingsPattern, OnePatternSettings>
+    AllPatternsSettings;
+
 const char* kDisplayPattern = "displayPattern";
 const char* kSetting = "setting";
 const char* kOrigin = "origin";
 const char* kSource = "source";
 const char* kEmbeddingOrigin = "embeddingOrigin";
 
 const ContentSettingsTypeNameEntry kContentSettingsTypeGroupNames[] = {
   {CONTENT_SETTINGS_TYPE_COOKIES, "cookies"},
   {CONTENT_SETTINGS_TYPE_IMAGES, "images"},
   {CONTENT_SETTINGS_TYPE_JAVASCRIPT, "javascript"},
@@ skipping 39 matching lines @@
     return CONTENT_SETTING_ASK;
   if (name == "block")
     return CONTENT_SETTING_BLOCK;
   if (name == "session")
     return CONTENT_SETTING_SESSION_ONLY;
 
   NOTREACHED() << name << " is not a recognized content setting.";
   return CONTENT_SETTING_DEFAULT;
 }
 
-std::string GeolocationExceptionToString(const GURL& origin,
-                                         const GURL& embedding_origin) {
+std::string GeolocationExceptionToString(
+    const ContentSettingsPattern& origin,
+    const ContentSettingsPattern& embedding_origin) {
   if (origin == embedding_origin)
-    return content_settings_helper::OriginToString(origin);
+    return origin.ToString();
 
   // TODO(estade): the page needs to use CSS to indent the string.
   std::string indent(" ");
-  if (embedding_origin.is_empty()) {
+
+  if (embedding_origin == ContentSettingsPattern::Wildcard()) {
     // NOTE: As long as the user cannot add/edit entries from the exceptions
     // dialog, it's impossible to actually have a non-default setting for some
     // origin "embedded on any other site", so this row will never appear.  If
     // we add the ability to add/edit exceptions, we'll need to decide when to
     // display this and how "removing" it will function.
     return indent +
         l10n_util::GetStringUTF8(IDS_EXCEPTIONS_GEOLOCATION_EMBEDDED_ANY_OTHER);
   }
 
   return indent + l10n_util::GetStringFUTF8(
       IDS_EXCEPTIONS_GEOLOCATION_EMBEDDED_ON_HOST,
-      UTF8ToUTF16(content_settings_helper::OriginToString(embedding_origin)));
+      UTF8ToUTF16(embedding_origin.ToString()));
 }
 
 // Create a DictionaryValue* that will act as a data source for a single row
 // in a HostContentSettingsMap-controlled exceptions table (e.g., cookies).
 // Ownership of the pointer is passed to the caller.
 DictionaryValue* GetExceptionForPage(
     const ContentSettingsPattern& pattern,
     ContentSetting setting,
     std::string provider_name) {
   DictionaryValue* exception = new DictionaryValue();
   exception->Set(
       kDisplayPattern,
       new StringValue(pattern.ToString()));
   exception->Set(
       kSetting,
       new StringValue(ContentSettingToString(setting)));
   exception->Set(
       kSource,
       new StringValue(provider_name));
   return exception;
 }
 
 // Create a DictionaryValue* that will act as a data source for a single row
 // in the Geolocation exceptions table. Ownership of the pointer is passed to
 // the caller.
-DictionaryValue* GetGeolocationExceptionForPage(const GURL& origin,
-                                                const GURL& embedding_origin,
-                                                ContentSetting setting) {
+DictionaryValue* GetGeolocationExceptionForPage(
+    const ContentSettingsPattern& origin,
+    const ContentSettingsPattern& embedding_origin,
+    ContentSetting setting) {
   DictionaryValue* exception = new DictionaryValue();
   exception->Set(
       kDisplayPattern,
       new StringValue(GeolocationExceptionToString(origin, embedding_origin)));

[Bernhard Bauer, 2011/08/03 15:22:50]

While you're here, could you change this to use SetString?

[markusheintz_, 2011/08/04 12:45:56]

Absolutely!

   exception->Set(
       kSetting,
       new StringValue(ContentSettingToString(setting)));
   exception->Set(
       kOrigin,
-      new StringValue(origin.spec()));
+      new StringValue(origin.ToString()));
   exception->Set(
       kEmbeddingOrigin,
-      new StringValue(embedding_origin.spec()));
+      new StringValue(embedding_origin.ToString()));
   return exception;
 }
 
 // Create a DictionaryValue* that will act as a data source for a single row
 // in the desktop notifications exceptions table. Ownership of the pointer is
 // passed to the caller.
 DictionaryValue* GetNotificationExceptionForPage(
     const GURL& url,
     ContentSetting setting) {
   DictionaryValue* exception = new DictionaryValue();
@@ skipping 252 matching lines @@
     case CONTENT_SETTINGS_TYPE_GEOLOCATION:
     case CONTENT_SETTINGS_TYPE_NOTIFICATIONS:
       break;
     default:
       UpdateExceptionsViewFromOTRHostContentSettingsMap(type);
       break;
   }
 }
 
 void ContentSettingsHandler::UpdateGeolocationExceptionsView() {
-  GeolocationContentSettingsMap* map =
-      web_ui_->GetProfile()->GetGeolocationContentSettingsMap();
-  GeolocationContentSettingsMap::AllOriginsSettings all_settings =
-      map->GetAllOriginsSettings();
-  GeolocationContentSettingsMap::AllOriginsSettings::const_iterator i;
+  HostContentSettingsMap* map =
+      web_ui_->GetProfile()->GetHostContentSettingsMap();
+
+  HostContentSettingsMap::SettingsForOneType all_settings;
+  map->GetSettingsForOneType(
+      CONTENT_SETTINGS_TYPE_GEOLOCATION,
+      std::string(),
+      &all_settings);
+
+  // Group geolocation settings by primary_pattern.
+  AllPatternsSettings all_patterns_settings;
+  for (HostContentSettingsMap::SettingsForOneType::iterator i =
+           all_settings.begin();
+       i != all_settings.end();
+       ++i) {
+    all_patterns_settings[i->a][i->b] = i->c;
+  }
 
   ListValue exceptions;
-  for (i = all_settings.begin(); i != all_settings.end(); ++i) {
-    const GURL& origin = i->first;
-    const GeolocationContentSettingsMap::OneOriginSettings& one_settings =
-        i->second;
+  for (AllPatternsSettings::iterator i = all_patterns_settings.begin();
+       i != all_patterns_settings.end();
+       ++i) {
+    const ContentSettingsPattern& primary_pattern = i->first;
+    const OnePatternSettings& one_settings = i->second;
 
-    GeolocationContentSettingsMap::OneOriginSettings::const_iterator parent =
-        one_settings.find(origin);
+    OnePatternSettings::const_iterator parent =
+        one_settings.find(primary_pattern);
 
     // Add the "parent" entry for the non-embedded setting.
     ContentSetting parent_setting =
         parent == one_settings.end() ? CONTENT_SETTING_DEFAULT : parent->second;
-    exceptions.Append(
-        GetGeolocationExceptionForPage(origin, origin, parent_setting));
+    exceptions.Append(GetGeolocationExceptionForPage(primary_pattern,
+                                                     primary_pattern,
+                                                     parent_setting));
 
     // Add the "children" for any embedded settings.
-    GeolocationContentSettingsMap::OneOriginSettings::const_iterator j;
-    for (j = one_settings.begin(); j != one_settings.end(); ++j) {
+    for (OnePatternSettings::const_iterator j = one_settings.begin();
+         j != one_settings.end();
+         ++j) {
       // Skip the non-embedded setting which we already added above.
       if (j == parent)
         continue;
 
       exceptions.Append(
-          GetGeolocationExceptionForPage(origin, j->first, j->second));
+          GetGeolocationExceptionForPage(primary_pattern, j->first, j->second));
     }
   }
 
   StringValue type_string(
       ContentSettingsTypeToGroupName(CONTENT_SETTINGS_TYPE_GEOLOCATION));
   web_ui_->CallJavascriptFunction("ContentSettings.setExceptions",
                                   type_string, exceptions);
 
   // This is mainly here to keep this function ideologically parallel to
   // UpdateExceptionsViewFromHostContentSettingsMap().
@@ skipping 112 matching lines @@
 
   ContentSettingsType type = ContentSettingsTypeFromGroupName(type_string);
   if (type == CONTENT_SETTINGS_TYPE_GEOLOCATION) {
     std::string origin;
     std::string embedding_origin;
     bool rv = args->GetString(arg_i++, &origin);
     DCHECK(rv);
     rv = args->GetString(arg_i++, &embedding_origin);
     DCHECK(rv);
 
-    web_ui_->GetProfile()->GetGeolocationContentSettingsMap()->
-        SetContentSetting(GURL(origin),
-                          GURL(embedding_origin),
+    web_ui_->GetProfile()->GetHostContentSettingsMap()->
+        SetContentSetting(ContentSettingsPattern::FromString(origin),
+                          ContentSettingsPattern::FromString(embedding_origin),
+                          CONTENT_SETTINGS_TYPE_GEOLOCATION,
+                          std::string(),
                           CONTENT_SETTING_DEFAULT);
   } else if (type == CONTENT_SETTINGS_TYPE_NOTIFICATIONS) {
     std::string origin;
     std::string setting;
     bool rv = args->GetString(arg_i++, &origin);
     DCHECK(rv);
     rv = args->GetString(arg_i++, &setting);
     DCHECK(rv);
     ContentSetting content_setting = ContentSettingFromString(setting);
     if (content_setting == CONTENT_SETTING_ALLOW) {
@@ skipping 107 matching lines @@
   return web_ui_->GetProfile()->GetProtocolHandlerRegistry();
 }
 
 HostContentSettingsMap*
     ContentSettingsHandler::GetOTRContentSettingsMap() {
   Profile* profile = web_ui_->GetProfile();
   if (profile->HasOffTheRecordProfile())
     return profile->GetOffTheRecordProfile()->GetHostContentSettingsMap();
   return NULL;
 }