Allow retrieval of media device ID salt even after ResourceContext has gone away.

chrome/browser/profiles/profile_io_data.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/profiles/profile_io_data.h"
 
 #include <string>
 
 #include "base/basictypes.h"
 #include "base/bind.h"
@@ skipping 401 matching lines @@
     sync_disabled_.MoveToThread(io_message_loop_proxy);
 
     signin_allowed_.Init(prefs::kSigninAllowed, pref_service);
     signin_allowed_.MoveToThread(io_message_loop_proxy);
   }
 
   quick_check_enabled_.Init(prefs::kQuickCheckEnabled,
                             local_state_pref_service);
   quick_check_enabled_.MoveToThread(io_message_loop_proxy);
 
-  media_device_id_salt_.reset(new MediaDeviceIDSalt(pref_service,
-                                                    is_incognito()));
+  media_device_id_salt_ = new MediaDeviceIDSalt(pref_service, is_incognito());
 
   network_prediction_enabled_.Init(prefs::kNetworkPredictionEnabled,
                                    pref_service);
   network_prediction_enabled_.MoveToThread(io_message_loop_proxy);
 
 #if defined(OS_CHROMEOS)
   cert_verifier_ = policy::PolicyCertServiceFactory::CreateForProfile(profile);
 #endif
   // The URLBlacklistManager has to be created on the UI thread to register
   // observers of |pref_service|, and it also has to clean up on
@@ skipping 289 matching lines @@
   // Allow either Init() or SetCookieSettingsForTesting() to initialize.
   DCHECK(initialized_ || cookie_settings_.get());
   return cookie_settings_.get();
 }
 
 HostContentSettingsMap* ProfileIOData::GetHostContentSettingsMap() const {
   DCHECK(initialized_);
   return host_content_settings_map_.get();
 }
 
-std::string ProfileIOData::GetMediaDeviceIDSalt() const {
-  return media_device_id_salt_->GetSalt();
+ResourceContext::SaltCallback ProfileIOData::GetMediaDeviceIDSalt() const {
+  return base::Bind(&MediaDeviceIDSalt::GetSalt, media_device_id_salt_);
 }
 
 void ProfileIOData::InitializeMetricsEnabledStateOnUIThread() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 #if defined(OS_CHROMEOS)
   // Just fetch the value from ChromeOS' settings while we're on the UI thread.
   // TODO(stevet): For now, this value is only set on profile initialization.
   // We will want to do something similar to the PrefMember method below in the
   // future to more accurately capture this state.
   chromeos::CrosSettings::Get()->GetBoolean(chromeos::kStatsReportingPref,
@@ skipping 124 matching lines @@
 
 bool ProfileIOData::ResourceContext::AllowContentAccess(
     const GURL& origin, ContentSettingsType type) {
   HostContentSettingsMap* content_settings =
       io_data_->GetHostContentSettingsMap();
   ContentSetting setting = content_settings->GetContentSetting(
       origin, origin, type, NO_RESOURCE_IDENTIFIER);
   return setting == CONTENT_SETTING_ALLOW;
 }
 
-std::string ProfileIOData::ResourceContext::GetMediaDeviceIDSalt() {
+ResourceContext::SaltCallback
+ProfileIOData::ResourceContext::GetMediaDeviceIDSalt() {
   return io_data_->GetMediaDeviceIDSalt();
 }
 
 // static
 std::string ProfileIOData::GetSSLSessionCacheShard() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   // The SSL session cache is partitioned by setting a string. This returns a
   // unique string to partition the SSL session cache. Each time we create a
   // new profile, we'll get a fresh SSL session cache which is separate from
   // the other profiles.
@@ skipping 249 matching lines @@
 void ProfileIOData::SetCookieSettingsForTesting(
     CookieSettings* cookie_settings) {
   DCHECK(!cookie_settings_.get());
   cookie_settings_ = cookie_settings;
 }
 
 void ProfileIOData::set_signin_names_for_testing(
     SigninNamesOnIOThread* signin_names) {
   signin_names_.reset(signin_names);
 }