Make geolocation API and X-Geo header access consistent

chrome/browser/content_settings/host_content_settings_map_unittest.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 <memory>
 #include <string>
 
 #include "base/auto_reset.h"
 #include "base/command_line.h"
 #include "base/json/json_reader.h"
@@ skipping 1232 matching lines @@
   host_content_settings_map->AddObserver(&mock_observer);
 
   EXPECT_EQ(CONTENT_SETTING_ALLOW,
             host_content_settings_map->GetContentSetting(
                 host, host, CONTENT_SETTINGS_TYPE_COOKIES, std::string()));
   host_content_settings_map->SetContentSettingDefaultScope(
       host, GURL(), CONTENT_SETTINGS_TYPE_COOKIES, std::string(),
       CONTENT_SETTING_DEFAULT);
 }
 
+// Guest profiles do not exist on Android, so don't run these tests there.
+#if !defined(OS_ANDROID)
 TEST_F(HostContentSettingsMapTest, GuestProfile) {
   TestingProfile profile;
   profile.SetGuestSession(true);
   HostContentSettingsMap* host_content_settings_map =
       HostContentSettingsMapFactory::GetForProfile(&profile);
 
   GURL host("http://example.com/");
   ContentSettingsPattern pattern =
       ContentSettingsPattern::FromString("[*.]example.com");
 
@@ skipping 51 matching lines @@
   profile.GetPrefs()->Set(GetPrefName(CONTENT_SETTINGS_TYPE_COOKIES), *value);
 
   // Test that during construction all the prefs get cleared.
   HostContentSettingsMapFactory::GetForProfile(&profile);
 
   const base::DictionaryValue* all_settings_dictionary =
       profile.GetPrefs()->GetDictionary(
           GetPrefName(CONTENT_SETTINGS_TYPE_COOKIES));
   EXPECT_TRUE(all_settings_dictionary->empty());
 }
+#endif  // !defined(OS_ANDROID)
 
 TEST_F(HostContentSettingsMapTest, MigrateDomainScopedSettings) {
   TestingProfile profile;
   HostContentSettingsMap* host_content_settings_map =
       HostContentSettingsMapFactory::GetForProfile(&profile);
   PrefService* prefs = profile.GetPrefs();
   // Set the pref to its initial state so that migration can be done later in
   // the test (normally it is done on construction of HostContentSettingsMap).
   int default_value;
   prefs->GetDefaultPrefValue(prefs::kDomainToOriginMigrationStatus)
@@ skipping 156 matching lines @@
   EXPECT_EQ(CONTENT_SETTING_ALLOW,
             host_content_settings_map->GetContentSetting(
                 https_host_narrower, https_host_narrower,
                 CONTENT_SETTINGS_TYPE_COOKIES, std::string()));
 }
 
 // Ensure that migration only happens once upon construction of the HCSM and
 // once after syncing (even when these events occur multiple times).
 TEST_F(HostContentSettingsMapTest, DomainToOriginMigrationStatus) {
   TestingProfile profile;
+
+  // Construct the map now to make the various platforms equivalent. On Android
+  // the map is created with the profile (due to dependencies), while on other
+  // platforms it is created lazily. Note, migration should be run here.
+  HostContentSettingsMap* host_content_settings_map =
+      HostContentSettingsMapFactory::GetForProfile(&profile);
+
   PrefService* prefs = profile.GetPrefs();
 
   GURL http_host("http://example.com/");
   GURL http_host_narrower("http://a.example.com/");
   std::string host_pattern_string =
       ContentSettingsPattern::FromURL(http_host).ToString();
 
   {
     DictionaryPrefUpdate update(prefs,
                                 GetPrefName(CONTENT_SETTINGS_TYPE_POPUPS));
     base::DictionaryValue* all_settings_dictionary = update.Get();
     ASSERT_TRUE(NULL != all_settings_dictionary);
 
     base::DictionaryValue* domain_setting = new base::DictionaryValue;
     domain_setting->SetInteger("setting", CONTENT_SETTING_ALLOW);
     all_settings_dictionary->SetWithoutPathExpansion(host_pattern_string + ",*",
                                                      domain_setting);
   }
 
   const base::DictionaryValue* all_settings_dictionary =
       prefs->GetDictionary(GetPrefName(CONTENT_SETTINGS_TYPE_POPUPS));
   const base::DictionaryValue* result = NULL;
   EXPECT_TRUE(all_settings_dictionary->GetDictionaryWithoutPathExpansion(
       "[*.]example.com,*", &result));
 
-  // Migration is done on construction of HostContentSettingsMap.
-  HostContentSettingsMap* host_content_settings_map =
-      HostContentSettingsMapFactory::GetForProfile(&profile);
+  // Migration is done on construction of HostContentSettingsMap. Try to run it
+  // again. This should not do anything as it has already ran.
+  host_content_settings_map->MigrateDomainScopedSettings(
+      false /* after_sync */);
 
   // Change default setting to BLOCK.
   host_content_settings_map->SetDefaultContentSetting(
       CONTENT_SETTINGS_TYPE_POPUPS, CONTENT_SETTING_BLOCK);
+
   EXPECT_EQ(
       CONTENT_SETTING_ALLOW,
       host_content_settings_map->GetContentSetting(
+          http_host, http_host, CONTENT_SETTINGS_TYPE_POPUPS, std::string()));
+
+  // The setting should still be allow as it hasn't been migrated.
+  EXPECT_EQ(CONTENT_SETTING_ALLOW,
+            host_content_settings_map->GetContentSetting(
+                http_host_narrower, http_host_narrower,
+                CONTENT_SETTINGS_TYPE_POPUPS, std::string()));
+
+  // Set the pref to its initial state so that migration can be triggered again,
+  // just for the sake of testing.
+  int default_value;
+  prefs->GetDefaultPrefValue(prefs::kDomainToOriginMigrationStatus)
+      ->GetAsInteger(&default_value);
+  prefs->SetInteger(prefs::kDomainToOriginMigrationStatus, default_value);
+
+  // Now, do the migration. This should work as we've cleared the pref back to
+  // its default value.
+  host_content_settings_map->MigrateDomainScopedSettings(false);
+
+  // Now the settings should be migrated.
+  EXPECT_EQ(
+      CONTENT_SETTING_ALLOW,
+      host_content_settings_map->GetContentSetting(
           http_host, http_host, CONTENT_SETTINGS_TYPE_POPUPS, std::string()));
   // Settings only apply to origins. Migration got executed.
   EXPECT_EQ(CONTENT_SETTING_BLOCK,
             host_content_settings_map->GetContentSetting(
                 http_host_narrower, http_host_narrower,
                 CONTENT_SETTINGS_TYPE_POPUPS, std::string()));
 
   GURL https_host("https://example.com/");
   GURL https_host_narrower("https://a.example.com/");
 
   host_content_settings_map->SetContentSettingCustomScope(
       ContentSettingsPattern::FromURL(https_host),
       ContentSettingsPattern::Wildcard(), CONTENT_SETTINGS_TYPE_POPUPS,
       std::string(), CONTENT_SETTING_ALLOW);
+
   EXPECT_EQ(
       CONTENT_SETTING_ALLOW,
       host_content_settings_map->GetContentSetting(
           https_host, https_host, CONTENT_SETTINGS_TYPE_POPUPS, std::string()));
   // Settings apply to subdomains.
   EXPECT_EQ(CONTENT_SETTING_ALLOW,
             host_content_settings_map->GetContentSetting(
                 https_host_narrower, https_host_narrower,
                 CONTENT_SETTINGS_TYPE_POPUPS, std::string()));
 
@@ skipping 155 matching lines @@
   EXPECT_TRUE(map->CanSetNarrowestContentSetting(
       valid_url, valid_url,
       CONTENT_SETTINGS_TYPE_POPUPS));
 
   GURL invalid_url("about:blank");
   EXPECT_FALSE(map->CanSetNarrowestContentSetting(
       invalid_url, invalid_url,
       CONTENT_SETTINGS_TYPE_POPUPS));
 }