Use ThreadChecker rather than DCHECK_CURRENTLY_ON.

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 "chrome/browser/content_settings/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 10 matching lines @@
 #include "chrome/browser/content_settings/content_settings_utils.h"
 #include "chrome/browser/prefs/browser_prefs.h"
 #include "chrome/browser/prefs/pref_service_mock_factory.h"
 #include "chrome/browser/prefs/pref_service_syncable.h"
 #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/pref_registry/pref_registry_syncable.h"
-#include "content/public/test/test_browser_thread.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "url/gurl.h"
 
 using ::testing::_;
-using content::BrowserThread;
 
 namespace content_settings {
 
 class DeadlockCheckerThread : public base::PlatformThread::Delegate {
  public:
   explicit DeadlockCheckerThread(PrefProvider* provider)
       : provider_(provider) {}
 
   virtual void ThreadMain() override {
     bool got_lock = provider_->lock_.Try();
@@ skipping 38 matching lines @@
     base::PlatformThread::Join(handle);
     notification_received_ = true;
   }
 
   PrefProvider* provider_;
   PrefChangeRegistrar pref_change_registrar_;
   bool notification_received_;
   DISALLOW_COPY_AND_ASSIGN(DeadlockCheckerObserver);
 };
 
-class PrefProviderTest : public testing::Test {
- public:
-  PrefProviderTest() : ui_thread_(
-      BrowserThread::UI, &message_loop_) {
-  }
-
- protected:
-  base::MessageLoop message_loop_;
-  content::TestBrowserThread ui_thread_;
-};
-
-TEST_F(PrefProviderTest, Observer) {
+TEST(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_F(PrefProviderTest, Incognito) {
+TEST(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_F(PrefProviderTest, GetContentSettingsValue) {
+TEST(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_F(PrefProviderTest, Patterns) {
+TEST(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_F(PrefProviderTest, ResourceIdentifier) {
+TEST(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_F(PrefProviderTest, AutoSubmitCertificateContentSetting) {
+TEST(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_F(PrefProviderTest, Deadlock) {
+TEST(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_F(PrefProviderTest, LastUsage) {
+TEST(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 15 matching lines @@
   base::Time second = pref_content_settings_provider.GetLastUsage(
       pattern, pattern, CONTENT_SETTINGS_TYPE_GEOLOCATION);
 
   base::TimeDelta delta = second - first;
   EXPECT_EQ(delta.InSeconds(), 10);
 
   pref_content_settings_provider.ShutdownOnUIThread();
 }
 
 }  // namespace content_settings