Remove content dependencies from content settings providers.

chrome/browser/content_settings/content_settings_policy_provider_unittest.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/content_settings/content_settings_policy_provider.h"
 
 #include <string>
 
 #include "base/auto_reset.h"
 #include "base/command_line.h"
 #include "base/memory/scoped_ptr.h"
-#include "base/message_loop/message_loop.h"
 #include "base/prefs/pref_service.h"
 #include "chrome/browser/content_settings/content_settings_mock_observer.h"
 #include "chrome/browser/content_settings/content_settings_utils.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/content_settings/core/browser/content_settings_rule.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 {
 
 typedef std::vector<Rule> Rules;
 
-class PolicyProviderTest : public testing::Test {
- public:
-  PolicyProviderTest()
-      : ui_thread_(BrowserThread::UI, &message_loop_) {
-  }
-
- protected:
-  // TODO(markusheintz): Check if it's possible to derive the provider class
-  // from NonThreadSafe and to use native thread identifiers instead of
-  // BrowserThread IDs. Then we could get rid of the message_loop and ui_thread
-  // fields.
-  base::MessageLoop message_loop_;
-  content::TestBrowserThread ui_thread_;

[Bernhard Bauer, 2014/09/23 10:08:19]

There is content::TestBrowserThreadBundle now to replace these two.

[Jun Mukai, 2014/09/23 20:48:44]

The point of this CL is to remove content/ dependency as far as possible. The
motivation is iOS support; if a file depends on content/ layer, it gets
unavailable on iOS.

If TestBrowserThreadBundle is a good solution if it needs to check
BrowserThread, but as far as I see, I don't think it needs. The check was
translated as "these methods need to run in the thread the provider was created"
(and Profile code verifies it's truly created on BrowserThread::UI). So this
threading code can be removed.

[Bernhard Bauer, 2014/09/24 08:15:31]

Fair enough. Ideally, we'd have something to enforce that this class is used on
the same thread as PrefService (independent of which thread that is), but yeah,
using ThreadChecker works too.

-};
-
-TEST_F(PolicyProviderTest, DefaultGeolocationContentSetting) {
+TEST(PolicyProviderTest, DefaultGeolocationContentSetting) {
   TestingProfile profile;
   TestingPrefServiceSyncable* prefs = profile.GetTestingPrefService();
   PolicyProvider provider(prefs);
 
   Rules rules;
 
   scoped_ptr<RuleIterator> rule_iterator(
       provider.GetRuleIterator(
           CONTENT_SETTINGS_TYPE_GEOLOCATION,
           std::string(),
@@ skipping 13 matching lines @@
   Rule rule = rule_iterator->Next();
   EXPECT_FALSE(rule_iterator->HasNext());
 
   EXPECT_EQ(ContentSettingsPattern::Wildcard(), rule.primary_pattern);
   EXPECT_EQ(ContentSettingsPattern::Wildcard(), rule.secondary_pattern);
   EXPECT_EQ(CONTENT_SETTING_BLOCK, ValueToContentSetting(rule.value.get()));
 
   provider.ShutdownOnUIThread();
 }
 
-TEST_F(PolicyProviderTest, ManagedDefaultContentSettings) {
+TEST(PolicyProviderTest, ManagedDefaultContentSettings) {
   TestingProfile profile;
   TestingPrefServiceSyncable* prefs = profile.GetTestingPrefService();
   PolicyProvider provider(prefs);
 
   prefs->SetManagedPref(prefs::kManagedDefaultPluginsSetting,
                         new base::FundamentalValue(CONTENT_SETTING_BLOCK));
 
   scoped_ptr<RuleIterator> rule_iterator(
       provider.GetRuleIterator(
           CONTENT_SETTINGS_TYPE_PLUGINS,
           std::string(),
           false));
   EXPECT_TRUE(rule_iterator->HasNext());
   Rule rule = rule_iterator->Next();
   EXPECT_FALSE(rule_iterator->HasNext());
 
   EXPECT_EQ(ContentSettingsPattern::Wildcard(), rule.primary_pattern);
   EXPECT_EQ(ContentSettingsPattern::Wildcard(), rule.secondary_pattern);
   EXPECT_EQ(CONTENT_SETTING_BLOCK, ValueToContentSetting(rule.value.get()));
 
   provider.ShutdownOnUIThread();
 }
 
 // When a default-content-setting is set to a managed setting a
 // CONTENT_SETTINGS_CHANGED notification should be fired. The same should happen
 // if the managed setting is removed.
-TEST_F(PolicyProviderTest, ObserveManagedSettingsChange) {
+TEST(PolicyProviderTest, ObserveManagedSettingsChange) {
   TestingProfile profile;
   TestingPrefServiceSyncable* prefs = profile.GetTestingPrefService();
   PolicyProvider provider(prefs);
 
   MockObserver mock_observer;
   EXPECT_CALL(mock_observer,
               OnContentSettingChanged(_,
                                       _,
                                       CONTENT_SETTINGS_TYPE_DEFAULT,
                                       ""));
   provider.AddObserver(&mock_observer);
 
   // Set the managed default-content-setting.
   prefs->SetManagedPref(prefs::kManagedDefaultImagesSetting,
                         new base::FundamentalValue(CONTENT_SETTING_BLOCK));
   ::testing::Mock::VerifyAndClearExpectations(&mock_observer);
   EXPECT_CALL(mock_observer,
               OnContentSettingChanged(_,
                                       _,
                                       CONTENT_SETTINGS_TYPE_DEFAULT,
                                       ""));
   // Remove the managed default-content-setting.
   prefs->RemoveManagedPref(prefs::kManagedDefaultImagesSetting);
   provider.ShutdownOnUIThread();
 }
 
-TEST_F(PolicyProviderTest, GettingManagedContentSettings) {
+TEST(PolicyProviderTest, GettingManagedContentSettings) {
   TestingProfile profile;
   TestingPrefServiceSyncable* prefs = profile.GetTestingPrefService();
 
   base::ListValue* value = new base::ListValue();
   value->Append(new base::StringValue("[*.]google.com"));
   prefs->SetManagedPref(prefs::kManagedImagesBlockedForUrls,
                         value);
 
   PolicyProvider provider(prefs);
 
@@ skipping 51 matching lines @@
             GetContentSetting(&provider,
                               youtube_url,
                               youtube_url,
                               CONTENT_SETTINGS_TYPE_COOKIES,
                               std::string(),
                               false));
 
   provider.ShutdownOnUIThread();
 }
 
-TEST_F(PolicyProviderTest, ResourceIdentifier) {
+TEST(PolicyProviderTest, ResourceIdentifier) {
   TestingProfile profile;
   TestingPrefServiceSyncable* prefs = profile.GetTestingPrefService();
 
   base::ListValue* value = new base::ListValue();
   value->Append(new base::StringValue("[*.]google.com"));
   prefs->SetManagedPref(prefs::kManagedPluginsAllowedForUrls,
                         value);
 
   PolicyProvider provider(prefs);
 
@@ skipping 16 matching lines @@
                               false));
 
   EXPECT_EQ(CONTENT_SETTING_DEFAULT,
             GetContentSetting(
                 &provider, google_url, google_url,
                 CONTENT_SETTINGS_TYPE_PLUGINS, "someplugin", false));
 
   provider.ShutdownOnUIThread();
 }
 
-TEST_F(PolicyProviderTest, AutoSelectCertificateList) {
+TEST(PolicyProviderTest, AutoSelectCertificateList) {
   TestingProfile profile;
   TestingPrefServiceSyncable* prefs = profile.GetTestingPrefService();
 
   PolicyProvider provider(prefs);
   GURL google_url("https://mail.google.com");
   // Tests the default setting for auto selecting certificates
   EXPECT_EQ(
       NULL,
       GetContentSettingValue(&provider,
                              google_url,
@@ skipping 31 matching lines @@
   ASSERT_EQ(base::Value::TYPE_DICTIONARY, cert_filter->GetType());
   base::DictionaryValue* dict_value =
       static_cast<base::DictionaryValue*>(cert_filter.get());
   std::string actual_common_name;
   ASSERT_TRUE(dict_value->GetString("ISSUER.CN", &actual_common_name));
   EXPECT_EQ("issuer name", actual_common_name);
   provider.ShutdownOnUIThread();
 }
 
 }  // namespace content_settings