Make safe browsing work in a multi-profile environment.

chrome/browser/profiles/profile_io_data.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/profiles/profile_io_data.h"
 
 #include <string>
 
 #include "base/basictypes.h"
 #include "base/command_line.h"
@@ skipping 195 matching lines @@
 }  // namespace
 
 void ProfileIOData::InitializeProfileParams(Profile* profile) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   PrefService* pref_service = profile->GetPrefs();
 
   scoped_ptr<ProfileParams> params(new ProfileParams);
   params->is_incognito = profile->IsOffTheRecord();
   params->clear_local_state_on_exit =
       pref_service->GetBoolean(prefs::kClearSiteDataOnExit);
+  params->safe_browsing_enabled =
+      pref_service->GetBoolean(prefs::kSafeBrowsingEnabled);
 
   params->appcache_service = profile->GetAppCacheService();
 
   // Set up Accept-Language and Accept-Charset header values
   params->accept_language = net::HttpUtil::GenerateAcceptLanguageHeader(
       pref_service->GetString(prefs::kAcceptLanguages));
   std::string default_charset = pref_service->GetString(prefs::kDefaultCharset);
   params->accept_charset =
       net::HttpUtil::GenerateAcceptCharsetHeader(default_charset);
 
@@ skipping 259 matching lines @@
 
   resource_context_.set_host_resolver(io_thread_globals->host_resolver.get());
   resource_context_.set_request_context(main_request_context_);
   resource_context_.set_database_tracker(database_tracker_);
   resource_context_.set_appcache_service(appcache_service_);
   resource_context_.set_blob_storage_context(blob_storage_context_);
   resource_context_.set_file_system_context(file_system_context_);
   resource_context_.set_quota_manager(quota_manager_);
   resource_context_.set_host_zoom_map(host_zoom_map_);
   resource_context_.set_prerender_manager(prerender_manager_);
+  resource_context_.set_safe_browsing_enabled(
+      profile_params_->safe_browsing_enabled);

[Joao da Silva, 2011/06/24 14:32:04]

This won't handle changes to the preference. For example, changing it in the
preferences UI won't enable/disable safe browsing until the browser is
restarted. I've had lots of trouble trying to fix this issue :-) I'm afraid this
solution won't make it easy to handle changes to the preference. I also dislike
that it makes ResourceContext, which lives in content, aware of safe browsing,
which is a browser feature.

I thought of having a BooleanPrefMember in ProfileIOData that follows the
kSafeBrowsingEnabled preference. The BooleanPrefMember is then moved to the IO
thread (like enable_referrers_). The BooleanPrefMember already observes the
preference, so every time it is queried it returns the current value. The
ProfileIOData just exposes a boolean method to get the current value.

Notice on the next line (499) that the resource_context has a reference to the
ProfileIOData. Other places get the ProfileIOData from the ResourceContext using
resource_context.GetUserData(NULL) (search for GetUserData in
chrome_content_browser_client.cc for examples).

I guess the same could be done for safe browsing: get the ProfileIOData in
resource_dispatcher_host.cc using GetUserData(NULL) and an ugly cast, and get
the preference value from there.

I tend to prefer this solution since it doesn't change ResourceContext, and
since it is also already used in other places. WDYT?

[Miranda Callahan, 2011/07/07 17:35:50]

Excellent idea -- done.

[mattm, 2011/07/07 21:34:55]

Note that the client side detection still wouldn't respond immediately to
changes, you'd have to close any tabs that had been open before the change.  

On the browser side, I guess TabContentsWrapper can observe the pref and
create/delete safebrowsing_detection_host_ as necessary.  It could then send an
IPC to the renderer to have ChromeRenderViewObserver create/delete the
phishing_classifier_.

   resource_context_.SetUserData(NULL, const_cast<ProfileIOData*>(this));
 
   LazyInitializeInternal(profile_params_.get());
 
   profile_params_.reset();
   initialized_ = true;
 }
 
 void ProfileIOData::ApplyProfileParamsToContext(
     ChromeURLRequestContext* context) const {
   context->set_is_incognito(profile_params_->is_incognito);
   context->set_accept_language(profile_params_->accept_language);
   context->set_accept_charset(profile_params_->accept_charset);
   context->set_referrer_charset(profile_params_->referrer_charset);
   context->set_transport_security_state(
       profile_params_->transport_security_state);
   context->set_ssl_config_service(profile_params_->ssl_config_service);
   context->set_appcache_service(profile_params_->appcache_service);
   context->set_blob_storage_context(profile_params_->blob_storage_context);
   context->set_file_system_context(profile_params_->file_system_context);
   context->set_extension_info_map(profile_params_->extension_info_map);
 }
 
 void ProfileIOData::ShutdownOnUIThread() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   enable_referrers_.Destroy();
 }