Remove content dependencies from content settings providers.

chrome/browser/content_settings/host_content_settings_map.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/host_content_settings_map.h"
 
 #include <utility>
 
 #include "base/basictypes.h"
 #include "base/command_line.h"
 #include "base/prefs/pref_service.h"
 #include "base/stl_util.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/time/clock.h"
 #include "chrome/browser/content_settings/content_settings_default_provider.h"
 #include "chrome/browser/content_settings/content_settings_policy_provider.h"
 #include "chrome/browser/content_settings/content_settings_pref_provider.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 "components/content_settings/core/browser/content_settings_details.h"
 #include "components/content_settings/core/browser/content_settings_observable_provider.h"
 #include "components/content_settings/core/browser/content_settings_provider.h"
 #include "components/content_settings/core/browser/content_settings_rule.h"
 #include "components/content_settings/core/common/content_settings_pattern.h"
 #include "components/pref_registry/pref_registry_syncable.h"
-#include "content/public/browser/browser_thread.h"
-#include "content/public/common/content_switches.h"
 #include "net/base/net_errors.h"
 #include "net/base/static_cookie_policy.h"
 #include "url/gurl.h"
 
 #if defined(ENABLE_EXTENSIONS)
 #include "extensions/common/constants.h"
 #endif
 
-using content::BrowserThread;
-
 namespace {
 
 typedef std::vector<content_settings::Rule> Rules;
 
 typedef std::pair<std::string, std::string> StringPair;
 
 // TODO(bauerb): Expose constants.
 const char* kProviderNames[] = {
   "platform_app",
   "policy",
@@ skipping 70 matching lines @@
   // Register the prefs for the content settings providers.
   content_settings::DefaultProvider::RegisterProfilePrefs(registry);
   content_settings::PrefProvider::RegisterProfilePrefs(registry);
   content_settings::PolicyProvider::RegisterProfilePrefs(registry);
   content_settings::OverrideProvider::RegisterProfilePrefs(registry);
 }
 
 void HostContentSettingsMap::RegisterProvider(
     ProviderType type,
     scoped_ptr<content_settings::ObservableProvider> provider) {
+  DCHECK(CalledOnValidThread());

[vabr (Chromium), 2014/09/23 07:51:00]

Instead of trying to get this functionality from NonThreadSafe, you can include
a thread checker as a data member, and check that, exactly as NonThreadSafe
does.

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

That is an idea. Please see Bauer's comment.

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

Yeah, that probably makes the most sense. You could put the ThreadChecker into
ObservableProvider, which is the base implementation for all the providers.

[vabr (Chromium), 2014/09/24 09:56:39]

+1 to putting the ThreadChecker (or NonThreadSafe) into ObservableProvider; but
I'm also fine with the current situation

   DCHECK(!content_settings_providers_[type]);
   provider->AddObserver(this);
   content_settings_providers_[type] = provider.release();
 
 #ifndef NDEBUG
   DCHECK_NE(used_from_thread_id_, base::kInvalidThreadId)
       << "Used from multiple threads before initialization complete.";
 #endif
 
   OnContentSettingChanged(ContentSettingsPattern(),
@@ skipping 180 matching lines @@
                     content_type,
                     resource_identifier,
                     value);
 }
 
 ContentSetting HostContentSettingsMap::GetContentSettingAndMaybeUpdateLastUsage(
     const GURL& primary_url,
     const GURL& secondary_url,
     ContentSettingsType content_type,
     const std::string& resource_identifier) {
-  DCHECK_CURRENTLY_ON(BrowserThread::UI);
+  DCHECK(CalledOnValidThread());
 
   ContentSetting setting = GetContentSetting(
       primary_url, secondary_url, content_type, resource_identifier);
   if (setting == CONTENT_SETTING_ALLOW) {
     UpdateLastUsageByPattern(
         ContentSettingsPattern::FromURLNoWildcard(primary_url),
         ContentSettingsPattern::FromURLNoWildcard(secondary_url),
         content_type);
   }
   return setting;
@@ skipping 224 matching lines @@
   FOR_EACH_OBSERVER(content_settings::Observer,
                     observers_,
                     OnContentSettingChanged(primary_pattern,
                                             secondary_pattern,
                                             content_type,
                                             resource_identifier));
 }
 
 HostContentSettingsMap::~HostContentSettingsMap() {
   DCHECK(!prefs_);
-  STLDeleteValues(&content_settings_providers_);
 }
 
 void HostContentSettingsMap::ShutdownOnUIThread() {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK(CalledOnValidThread());
   DCHECK(prefs_);
   prefs_ = NULL;
   for (ProviderIterator it = content_settings_providers_.begin();
        it != content_settings_providers_.end();
        ++it) {
     it->second->ShutdownOnUIThread();
   }
+  STLDeleteValues(&content_settings_providers_);
+  DetachFromThread();
 }
 
 void HostContentSettingsMap::MigrateObsoleteClearOnExitPref() {
   // Don't migrate more than once.
   if (prefs_->HasPrefPath(prefs::kContentSettingsClearOnExitMigrated) &&
       prefs_->GetBoolean(prefs::kContentSettingsClearOnExitMigrated)) {
     return;
   }
 
   if (!prefs_->GetBoolean(prefs::kClearSiteDataOnExit)) {
@@ skipping 203 matching lines @@
     }
   }
 
   if (info) {
     info->source = content_settings::SETTING_SOURCE_NONE;
     info->primary_pattern = ContentSettingsPattern();
     info->secondary_pattern = ContentSettingsPattern();
   }
   return scoped_ptr<base::Value>();
 }