Ensure tests have an active task runner

chrome/browser/content_settings/content_settings_pref_provider_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 "components/content_settings/core/browser/content_settings_pref_provider.h"
 
 #include "base/auto_reset.h"
 #include "base/command_line.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop.h"
@@ skipping 13 matching lines @@
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/common/url_constants.h"
 #include "chrome/test/base/testing_pref_service_syncable.h"
 #include "chrome/test/base/testing_profile.h"
 #include "components/content_settings/core/browser/content_settings_pref.h"
 #include "components/content_settings/core/browser/content_settings_rule.h"
 #include "components/content_settings/core/browser/content_settings_utils.h"
 #include "components/content_settings/core/test/content_settings_test_utils.h"
 #include "components/pref_registry/pref_registry_syncable.h"
+#include "content/public/test/test_browser_thread_bundle.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "url/gurl.h"
 
 using ::testing::_;
 
 namespace content_settings {
 
 class DeadlockCheckerThread : public base::PlatformThread::Delegate {
  public:
   explicit DeadlockCheckerThread(PrefProvider* provider)
@@ skipping 39 matching lines @@
     base::PlatformThread::Join(handle);
     notification_received_ = true;
   }
 
   PrefProvider* provider_;
   PrefChangeRegistrar pref_change_registrar_;
   bool notification_received_;
   DISALLOW_COPY_AND_ASSIGN(DeadlockCheckerObserver);
 };
 
-TEST(PrefProviderTest, Observer) {
+class PrefProviderTest : public testing::Test {
+  content::TestBrowserThreadBundle thread_bundle_;
+};
+
+TEST_F(PrefProviderTest, Observer) {
   TestingProfile profile;
   PrefProvider pref_content_settings_provider(profile.GetPrefs(), false);
 
   ContentSettingsPattern pattern =
       ContentSettingsPattern::FromString("[*.]example.com");
   content_settings::MockObserver mock_observer;
   EXPECT_CALL(mock_observer,
               OnContentSettingChanged(pattern,
                                       ContentSettingsPattern::Wildcard(),
                                       CONTENT_SETTINGS_TYPE_IMAGES,
                                       ""));
 
   pref_content_settings_provider.AddObserver(&mock_observer);
 
   pref_content_settings_provider.SetWebsiteSetting(
       pattern,
       ContentSettingsPattern::Wildcard(),
       CONTENT_SETTINGS_TYPE_IMAGES,
       std::string(),
       new base::FundamentalValue(CONTENT_SETTING_ALLOW));
 
   pref_content_settings_provider.ShutdownOnUIThread();
 }
 
 // Test for regression in which the PrefProvider modified the user pref store
 // of the OTR unintentionally: http://crbug.com/74466.
-TEST(PrefProviderTest, Incognito) {
+TEST_F(PrefProviderTest, Incognito) {
   PersistentPrefStore* user_prefs = new TestingPrefStore();
   OverlayUserPrefStore* otr_user_prefs =
       new OverlayUserPrefStore(user_prefs);
 
   PrefServiceMockFactory factory;
   factory.set_user_prefs(make_scoped_refptr(user_prefs));
   scoped_refptr<user_prefs::PrefRegistrySyncable> registry(
       new user_prefs::PrefRegistrySyncable);
   PrefServiceSyncable* regular_prefs =
       factory.CreateSyncable(registry.get()).release();
@@ skipping 46 matching lines @@
                               std::string(),
                               false));
   // But the value should not be overridden in the OTR user prefs accidentally.
   EXPECT_FALSE(otr_user_prefs->IsSetInOverlay(
       prefs::kContentSettingsPatternPairs));
 
   pref_content_settings_provider.ShutdownOnUIThread();
   pref_content_settings_provider_incognito.ShutdownOnUIThread();
 }
 
-TEST(PrefProviderTest, GetContentSettingsValue) {
+TEST_F(PrefProviderTest, GetContentSettingsValue) {
   TestingProfile testing_profile;
   PrefProvider provider(testing_profile.GetPrefs(), false);
 
   GURL primary_url("http://example.com/");
   ContentSettingsPattern primary_pattern =
       ContentSettingsPattern::FromString("[*.]example.com");
 
   EXPECT_EQ(CONTENT_SETTING_DEFAULT,
             GetContentSetting(&provider,
                               primary_url,
@@ skipping 41 matching lines @@
   EXPECT_EQ(NULL,
             GetContentSettingValue(&provider,
                                    primary_url,
                                    primary_url,
                                    CONTENT_SETTINGS_TYPE_IMAGES,
                                    std::string(),
                                    false));
   provider.ShutdownOnUIThread();
 }
 
-TEST(PrefProviderTest, Patterns) {
+TEST_F(PrefProviderTest, Patterns) {
   TestingProfile testing_profile;
   PrefProvider pref_content_settings_provider(testing_profile.GetPrefs(),
                                               false);
 
   GURL host1("http://example.com/");
   GURL host2("http://www.example.com/");
   GURL host3("http://example.org/");
   GURL host4("file:///tmp/test.html");
   ContentSettingsPattern pattern1 =
       ContentSettingsPattern::FromString("[*.]example.com");
@@ skipping 68 matching lines @@
             GetContentSetting(&pref_content_settings_provider,
                               host4,
                               host4,
                               CONTENT_SETTINGS_TYPE_IMAGES,
                               std::string(),
                               false));
 
   pref_content_settings_provider.ShutdownOnUIThread();
 }
 
-TEST(PrefProviderTest, ResourceIdentifier) {
+TEST_F(PrefProviderTest, ResourceIdentifier) {
   TestingProfile testing_profile;
   PrefProvider pref_content_settings_provider(testing_profile.GetPrefs(),
                                               false);
 
   GURL host("http://example.com/");
   ContentSettingsPattern pattern =
       ContentSettingsPattern::FromString("[*.]example.com");
   std::string resource1("someplugin");
   std::string resource2("otherplugin");
 
@@ skipping 15 matching lines @@
                 resource1, false));
   EXPECT_EQ(CONTENT_SETTING_DEFAULT,
             GetContentSetting(
                 &pref_content_settings_provider,
                 host, host, CONTENT_SETTINGS_TYPE_PLUGINS,
                 resource2, false));
 
   pref_content_settings_provider.ShutdownOnUIThread();
 }
 
-TEST(PrefProviderTest, AutoSubmitCertificateContentSetting) {
+TEST_F(PrefProviderTest, AutoSubmitCertificateContentSetting) {
   TestingProfile profile;
   TestingPrefServiceSyncable* prefs = profile.GetTestingPrefService();
   GURL primary_url("https://www.example.com");
   GURL secondary_url("https://www.sample.com");
 
   PrefProvider provider(prefs, false);
 
   EXPECT_EQ(CONTENT_SETTING_DEFAULT,
             GetContentSetting(
                 &provider,
@@ skipping 13 matching lines @@
                 &provider,
                 primary_url,
                 secondary_url,
                 CONTENT_SETTINGS_TYPE_AUTO_SELECT_CERTIFICATE,
                 std::string(),
                 false));
   provider.ShutdownOnUIThread();
 }
 
 // http://crosbug.com/17760
-TEST(PrefProviderTest, Deadlock) {
+TEST_F(PrefProviderTest, Deadlock) {
   TestingPrefServiceSyncable prefs;
   PrefProvider::RegisterProfilePrefs(prefs.registry());
 
   // Chain of events: a preference changes, |PrefProvider| notices it, and reads
   // and writes the preference. When the preference is written, a notification
   // is sent, and this used to happen when |PrefProvider| was still holding its
   // lock.
 
   PrefProvider provider(&prefs, false);
   DeadlockCheckerObserver observer(&prefs, &provider);
   {
     DictionaryPrefUpdate update(&prefs,
                                 prefs::kContentSettingsPatternPairs);
     base::DictionaryValue* mutable_settings = update.Get();
     mutable_settings->SetWithoutPathExpansion("www.example.com,*",
                                               new base::DictionaryValue());
   }
   EXPECT_TRUE(observer.notification_received());
 
   provider.ShutdownOnUIThread();
 }
 
-TEST(PrefProviderTest, LastUsage) {
+TEST_F(PrefProviderTest, LastUsage) {
   TestingProfile testing_profile;
   PrefProvider pref_content_settings_provider(testing_profile.GetPrefs(),
                                               false);
   base::SimpleTestClock* test_clock = new base::SimpleTestClock;
   test_clock->SetNow(base::Time::Now());
 
   pref_content_settings_provider.SetClockForTesting(
       scoped_ptr<base::Clock>(test_clock));
   GURL host("http://example.com/");
   ContentSettingsPattern pattern =
@@ skipping 19 matching lines @@
   EXPECT_EQ(delta.InSeconds(), 10);
 
   pref_content_settings_provider.ShutdownOnUIThread();
 }
 
 
 // TODO(msramek): This tests the correct migration behavior between the old
 // aggregate dictionary preferences for all content settings types and the new
 // dictionary preferences for individual types. Remove this when the migration
 // period is over.
-TEST(PrefProviderTest, SyncingOldToNew) {
+TEST_F(PrefProviderTest, SyncingOldToNew) {
   TestingPrefServiceSyncable prefs;
   PrefProvider::RegisterProfilePrefs(prefs.registry());
   PrefProvider provider(&prefs, false);
 
   const std::string pattern = "google.com,*";
   const std::string resource_id = "abcde12345";
   base::DictionaryValue* exceptions = new base::DictionaryValue();
   base::DictionaryValue* plugin_resources = new base::DictionaryValue();
 
   // Add exceptions for images and app banner.
@@ skipping 65 matching lines @@
     EXPECT_TRUE(plugins_exception->GetDictionaryWithoutPathExpansion(
         "per_resource", &resource_exception));
     EXPECT_TRUE(resource_exception->GetIntegerWithoutPathExpansion(
         resource_id, &resource_exception_value));
     EXPECT_EQ(CONTENT_SETTING_BLOCK, resource_exception_value);
   }
 
   provider.ShutdownOnUIThread();
 }
 
-TEST(PrefProviderTest, SyncingNewToOld) {
+TEST_F(PrefProviderTest, SyncingNewToOld) {
   TestingPrefServiceSyncable prefs;
   PrefProvider::RegisterProfilePrefs(prefs.registry());
   PrefProvider provider(&prefs, false);
 
   const std::string pattern = "google.com,*";
   const std::string resource_id = "abcde12345";
   base::DictionaryValue block_exception;
   block_exception.SetIntegerWithoutPathExpansion(
       "setting", CONTENT_SETTING_BLOCK);
 
@@ skipping 68 matching lines @@
         "per_plugin", &resource_values);
     resource_values->GetIntegerWithoutPathExpansion(
         resource_id, &resource_exception_value);
     DCHECK_EQ(CONTENT_SETTING_ALLOW, resource_exception_value);
   }
 
   provider.ShutdownOnUIThread();
 }
 
 #if defined(OS_CHROMEOS) || defined(OS_ANDROID)
-TEST(PrefProviderTest, PMIMigrateOnlyAllow) {
+TEST_F(PrefProviderTest, PMIMigrateOnlyAllow) {
   TestingPrefServiceSyncable prefs;
   PrefProvider::RegisterProfilePrefs(prefs.registry());
 
   const std::string pattern_1 = "google.com,*";
   const std::string pattern_2 = "www.google.com,*";
   base::DictionaryValue* exception_1 = new base::DictionaryValue();
   base::DictionaryValue* exception_2 = new base::DictionaryValue();
 
   // Add both an "allow" and "block" exception for PMI.
   exception_1->SetIntegerWithoutPathExpansion(
@@ skipping 20 matching lines @@
         &prefs, prefs::kContentSettingsProtectedMediaIdentifierPatternPairs);
     const base::DictionaryValue* pmi_dictionary = update.Get();
     EXPECT_FALSE(pmi_dictionary->HasKey(pattern_1));
     EXPECT_TRUE(pmi_dictionary->HasKey(pattern_2));
   }
 
   provider.ShutdownOnUIThread();
 }
 #endif
 
-TEST(PrefProviderTest, PrefsMigrateVerbatim) {
+TEST_F(PrefProviderTest, PrefsMigrateVerbatim) {
   TestingPrefServiceSyncable prefs;
   PrefProvider::RegisterProfilePrefs(prefs.registry());
 
   const std::string pattern_1 = "google.com,*";
   const std::string pattern_2 = "www.google.com,*";
   base::DictionaryValue* exception_1 = new base::DictionaryValue();
   base::DictionaryValue* exception_2 = new base::DictionaryValue();
   scoped_ptr<base::DictionaryValue> old_dictionary;
 
   // Add two exceptions.
@@ skipping 30 matching lines @@
   // Test if the value after copying there and back is the same.
   {
     DictionaryPrefUpdate update(&prefs, prefs::kContentSettingsPatternPairs);
     base::DictionaryValue* new_dictionary = update.Get();
     EXPECT_TRUE(old_dictionary->Equals(new_dictionary));
   }
 
   provider.ShutdownOnUIThread();
 }
 
-TEST(PrefProviderTest, IncognitoInheritsValueMap) {
+TEST_F(PrefProviderTest, IncognitoInheritsValueMap) {
   TestingPrefServiceSyncable prefs;
   PrefProvider::RegisterProfilePrefs(prefs.registry());
 
   ContentSettingsPattern pattern_1 =
       ContentSettingsPattern::FromString("google.com");
   ContentSettingsPattern pattern_2 =
       ContentSettingsPattern::FromString("www.google.com");
   ContentSettingsPattern wildcard =
       ContentSettingsPattern::FromString("*");
   scoped_ptr<base::Value> value(
@@ skipping 46 matching lines @@
         CONTENT_SETTINGS_TYPE_IMAGES, std::string(), true));
     EXPECT_TRUE(it->HasNext());
     EXPECT_EQ(pattern_2, it->Next().primary_pattern);
     EXPECT_FALSE(it->HasNext());
   }
 
   incognito_provider.ShutdownOnUIThread();
   normal_provider.ShutdownOnUIThread();
 }
 
-TEST(PrefProviderTest, ClearAllContentSettingsRules) {
+TEST_F(PrefProviderTest, ClearAllContentSettingsRules) {
   TestingPrefServiceSyncable prefs;
   PrefProvider::RegisterProfilePrefs(prefs.registry());
 
   ContentSettingsPattern pattern =
       ContentSettingsPattern::FromString("google.com");
   ContentSettingsPattern wildcard =
       ContentSettingsPattern::FromString("*");
   scoped_ptr<base::Value> value(
       new base::FundamentalValue(CONTENT_SETTING_ALLOW));
   ResourceIdentifier res_id("abcde");
@@ skipping 67 matching lines @@
     EXPECT_TRUE(exception->HasKey(GetTypeName(CONTENT_SETTINGS_TYPE_COOKIES)));
 
     // The notification setting was not cleared, but it was also never written
     // to the old preference, as it is unsyncable.
   }
 
   provider.ShutdownOnUIThread();
 }
 
 }  // namespace content_settings