Home | History | Annotate | Download | only in profiles 
      1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
      2 // Use of this source code is governed by a BSD-style license that can be
      3 // found in the LICENSE file.
      4 
      5 #include "chrome/browser/profiles/profile_io_data.h"
      6 
      7 #include <string>
      8 
      9 #include "base/basictypes.h"
     10 #include "base/bind.h"
     11 #include "base/bind_helpers.h"
     12 #include "base/callback.h"
     13 #include "base/command_line.h"
     14 #include "base/compiler_specific.h"
     15 #include "base/debug/alias.h"
     16 #include "base/logging.h"
     17 #include "base/path_service.h"
     18 #include "base/prefs/pref_service.h"
     19 #include "base/stl_util.h"
     20 #include "base/strings/string_number_conversions.h"
     21 #include "base/strings/string_util.h"
     22 #include "base/strings/stringprintf.h"
     23 #include "base/threading/sequenced_worker_pool.h"
     24 #include "chrome/browser/browser_process.h"
     25 #include "chrome/browser/chrome_notification_types.h"
     26 #include "chrome/browser/content_settings/content_settings_provider.h"
     27 #include "chrome/browser/content_settings/cookie_settings.h"
     28 #include "chrome/browser/content_settings/host_content_settings_map.h"
     29 #include "chrome/browser/custom_handlers/protocol_handler_registry.h"
     30 #include "chrome/browser/custom_handlers/protocol_handler_registry_factory.h"
     31 #include "chrome/browser/devtools/devtools_network_controller.h"
     32 #include "chrome/browser/devtools/devtools_network_transaction_factory.h"
     33 #include "chrome/browser/download/download_service.h"
     34 #include "chrome/browser/download/download_service_factory.h"
     35 #include "chrome/browser/extensions/extension_resource_protocols.h"
     36 #include "chrome/browser/io_thread.h"
     37 #include "chrome/browser/media/media_device_id_salt.h"
     38 #include "chrome/browser/net/about_protocol_handler.h"
     39 #include "chrome/browser/net/chrome_fraudulent_certificate_reporter.h"
     40 #include "chrome/browser/net/chrome_http_user_agent_settings.h"
     41 #include "chrome/browser/net/chrome_net_log.h"
     42 #include "chrome/browser/net/chrome_network_delegate.h"
     43 #include "chrome/browser/net/cookie_store_util.h"
     44 #include "chrome/browser/net/proxy_service_factory.h"
     45 #include "chrome/browser/profiles/profile.h"
     46 #include "chrome/browser/profiles/profile_manager.h"
     47 #include "chrome/browser/signin/signin_names_io_thread.h"
     48 #include "chrome/common/chrome_paths.h"
     49 #include "chrome/common/chrome_switches.h"
     50 #include "chrome/common/pref_names.h"
     51 #include "chrome/common/url_constants.h"
     52 #include "components/startup_metric_utils/startup_metric_utils.h"
     53 #include "components/sync_driver/pref_names.h"
     54 #include "components/url_fixer/url_fixer.h"
     55 #include "content/public/browser/browser_thread.h"
     56 #include "content/public/browser/host_zoom_map.h"
     57 #include "content/public/browser/notification_service.h"
     58 #include "content/public/browser/resource_context.h"
     59 #include "extensions/browser/extension_protocols.h"
     60 #include "extensions/browser/extension_system.h"
     61 #include "extensions/browser/info_map.h"
     62 #include "extensions/common/constants.h"
     63 #include "net/base/keygen_handler.h"
     64 #include "net/cookies/canonical_cookie.h"
     65 #include "net/http/http_transaction_factory.h"
     66 #include "net/http/http_util.h"
     67 #include "net/http/transport_security_persister.h"
     68 #include "net/proxy/proxy_config_service_fixed.h"
     69 #include "net/proxy/proxy_script_fetcher_impl.h"
     70 #include "net/proxy/proxy_service.h"
     71 #include "net/ssl/client_cert_store.h"
     72 #include "net/ssl/server_bound_cert_service.h"
     73 #include "net/url_request/data_protocol_handler.h"
     74 #include "net/url_request/file_protocol_handler.h"
     75 #include "net/url_request/ftp_protocol_handler.h"
     76 #include "net/url_request/url_request.h"
     77 #include "net/url_request/url_request_file_job.h"
     78 #include "net/url_request/url_request_intercepting_job_factory.h"
     79 #include "net/url_request/url_request_interceptor.h"
     80 #include "net/url_request/url_request_job_factory_impl.h"
     81 
     82 #if defined(ENABLE_CONFIGURATION_POLICY)
     83 #include "chrome/browser/policy/cloud/policy_header_service_factory.h"
     84 #include "chrome/browser/policy/policy_helpers.h"
     85 #include "components/policy/core/browser/url_blacklist_manager.h"
     86 #include "components/policy/core/common/cloud/policy_header_io_helper.h"
     87 #include "components/policy/core/common/cloud/policy_header_service.h"
     88 #include "components/policy/core/common/cloud/user_cloud_policy_manager.h"
     89 #endif
     90 
     91 #if defined(ENABLE_MANAGED_USERS)
     92 #include "chrome/browser/supervised_user/supervised_user_service.h"
     93 #include "chrome/browser/supervised_user/supervised_user_service_factory.h"
     94 #include "chrome/browser/supervised_user/supervised_user_url_filter.h"
     95 #endif
     96 
     97 #if defined(OS_CHROMEOS)
     98 #include "chrome/browser/chromeos/drive/drive_protocol_handler.h"
     99 #include "chrome/browser/chromeos/login/startup_utils.h"
    100 #include "chrome/browser/chromeos/login/users/user.h"
    101 #include "chrome/browser/chromeos/login/users/user_manager.h"
    102 #include "chrome/browser/chromeos/net/cert_verify_proc_chromeos.h"
    103 #include "chrome/browser/chromeos/policy/policy_cert_service.h"
    104 #include "chrome/browser/chromeos/policy/policy_cert_service_factory.h"
    105 #include "chrome/browser/chromeos/policy/policy_cert_verifier.h"
    106 #include "chrome/browser/chromeos/settings/cros_settings.h"
    107 #include "chromeos/dbus/cryptohome_client.h"
    108 #include "chromeos/dbus/dbus_thread_manager.h"
    109 #include "chromeos/settings/cros_settings_names.h"
    110 #include "crypto/nss_util.h"
    111 #include "crypto/nss_util_internal.h"
    112 #include "net/cert/multi_threaded_cert_verifier.h"
    113 #include "net/ssl/client_cert_store_chromeos.h"
    114 #endif  // defined(OS_CHROMEOS)
    115 
    116 #if defined(USE_NSS)
    117 #include "chrome/browser/ui/crypto_module_delegate_nss.h"
    118 #include "net/ssl/client_cert_store_nss.h"
    119 #endif
    120 
    121 #if defined(OS_WIN)
    122 #include "net/ssl/client_cert_store_win.h"
    123 #endif
    124 
    125 #if defined(OS_MACOSX)
    126 #include "net/ssl/client_cert_store_mac.h"
    127 #endif
    128 
    129 using content::BrowserContext;
    130 using content::BrowserThread;
    131 using content::ResourceContext;
    132 
    133 namespace {
    134 
    135 #if defined(DEBUG_DEVTOOLS)
    136 bool IsSupportedDevToolsURL(const GURL& url, base::FilePath* path) {
    137   std::string bundled_path_prefix(chrome::kChromeUIDevToolsBundledPath);
    138   bundled_path_prefix = "/" + bundled_path_prefix + "/";
    139 
    140   if (!url.SchemeIs(content::kChromeDevToolsScheme) ||
    141       url.host() != chrome::kChromeUIDevToolsHost ||
    142       !StartsWithASCII(url.path(), bundled_path_prefix, false)) {
    143     return false;
    144   }
    145 
    146   if (!url.is_valid()) {
    147     NOTREACHED();
    148     return false;
    149   }
    150 
    151   // Remove Query and Ref from URL.
    152   GURL stripped_url;
    153   GURL::Replacements replacements;
    154   replacements.ClearQuery();
    155   replacements.ClearRef();
    156   stripped_url = url.ReplaceComponents(replacements);
    157 
    158   std::string relative_path;
    159   const std::string& spec = stripped_url.possibly_invalid_spec();
    160   const url::Parsed& parsed = stripped_url.parsed_for_possibly_invalid_spec();
    161   int offset = parsed.CountCharactersBefore(url::Parsed::PATH, false);
    162   if (offset < static_cast<int>(spec.size()))
    163     relative_path.assign(spec.substr(offset + bundled_path_prefix.length()));
    164 
    165   // Check that |relative_path| is not an absolute path (otherwise
    166   // AppendASCII() will DCHECK).  The awkward use of StringType is because on
    167   // some systems FilePath expects a std::string, but on others a std::wstring.
    168   base::FilePath p(
    169       base::FilePath::StringType(relative_path.begin(), relative_path.end()));
    170   if (p.IsAbsolute())
    171     return false;
    172 
    173   base::FilePath inspector_dir;
    174   if (!PathService::Get(chrome::DIR_INSPECTOR, &inspector_dir))
    175     return false;
    176 
    177   if (inspector_dir.empty())
    178     return false;
    179 
    180   *path = inspector_dir.AppendASCII(relative_path);
    181   return true;
    182 }
    183 
    184 class DebugDevToolsInterceptor : public net::URLRequestInterceptor {
    185  public:
    186   DebugDevToolsInterceptor() {}
    187   virtual ~DebugDevToolsInterceptor() {}
    188 
    189   // net::URLRequestInterceptor implementation.
    190   virtual net::URLRequestJob* MaybeInterceptRequest(
    191       net::URLRequest* request,
    192       net::NetworkDelegate* network_delegate) const OVERRIDE {
    193     base::FilePath path;
    194     if (IsSupportedDevToolsURL(request->url(), &path))
    195       return new net::URLRequestFileJob(
    196           request, network_delegate, path,
    197           content::BrowserThread::GetBlockingPool()->
    198               GetTaskRunnerWithShutdownBehavior(
    199                   base::SequencedWorkerPool::SKIP_ON_SHUTDOWN));
    200 
    201     return NULL;
    202   }
    203 };
    204 #endif  // defined(DEBUG_DEVTOOLS)
    205 
    206 #if defined(OS_CHROMEOS)
    207 // The following four functions are responsible for initializing NSS for each
    208 // profile on ChromeOS, which has a separate NSS database and TPM slot
    209 // per-profile.
    210 //
    211 // Initialization basically follows these steps:
    212 // 1) Get some info from chromeos::UserManager about the User for this profile.
    213 // 2) Tell nss_util to initialize the software slot for this profile.
    214 // 3) Wait for the TPM module to be loaded by nss_util if it isn't already.
    215 // 4) Ask CryptohomeClient which TPM slot id corresponds to this profile.
    216 // 5) Tell nss_util to use that slot id on the TPM module.
    217 //
    218 // Some of these steps must happen on the UI thread, others must happen on the
    219 // IO thread:
    220 //               UI thread                              IO Thread
    221 //
    222 //  ProfileIOData::InitializeOnUIThread
    223 //                   |
    224 // chromeos::UserManager::GetUserByProfile
    225 //                   \---------------------------------------v
    226 //                                                 StartNSSInitOnIOThread
    227 //                                                           |
    228 //                                          crypto::InitializeNSSForChromeOSUser
    229 //                                                           |
    230 //                                                crypto::IsTPMTokenReady
    231 //                                                           |
    232 //                                          StartTPMSlotInitializationOnIOThread
    233 //                   v---------------------------------------/
    234 //     GetTPMInfoForUserOnUIThread
    235 //                   |
    236 // CryptohomeClient::Pkcs11GetTpmTokenInfoForUser
    237 //                   |
    238 //     DidGetTPMInfoForUserOnUIThread
    239 //                   \---------------------------------------v
    240 //                                          crypto::InitializeTPMForChromeOSUser
    241 
    242 void DidGetTPMInfoForUserOnUIThread(const std::string& username_hash,
    243                                     chromeos::DBusMethodCallStatus call_status,
    244                                     const std::string& label,
    245                                     const std::string& user_pin,
    246                                     int slot_id) {
    247   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
    248   if (call_status == chromeos::DBUS_METHOD_CALL_FAILURE) {
    249     NOTREACHED() << "dbus error getting TPM info for " << username_hash;
    250     return;
    251   }
    252   DVLOG(1) << "Got TPM slot for " << username_hash << ": " << slot_id;
    253   BrowserThread::PostTask(
    254       BrowserThread::IO,
    255       FROM_HERE,
    256       base::Bind(
    257           &crypto::InitializeTPMForChromeOSUser, username_hash, slot_id));
    258 }
    259 
    260 void GetTPMInfoForUserOnUIThread(const std::string& username,
    261                                  const std::string& username_hash) {
    262   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
    263   DVLOG(1) << "Getting TPM info from cryptohome for "
    264            << " " << username << " " << username_hash;
    265   chromeos::DBusThreadManager::Get()
    266       ->GetCryptohomeClient()
    267       ->Pkcs11GetTpmTokenInfoForUser(
    268             username,
    269             base::Bind(&DidGetTPMInfoForUserOnUIThread, username_hash));
    270 }
    271 
    272 void StartTPMSlotInitializationOnIOThread(const std::string& username,
    273                                           const std::string& username_hash) {
    274   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
    275 
    276   BrowserThread::PostTask(
    277       BrowserThread::UI,
    278       FROM_HERE,
    279       base::Bind(&GetTPMInfoForUserOnUIThread, username, username_hash));
    280 }
    281 
    282 void StartNSSInitOnIOThread(const std::string& username,
    283                             const std::string& username_hash,
    284                             const base::FilePath& path,
    285                             bool is_primary_user) {
    286   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
    287   DVLOG(1) << "Starting NSS init for " << username
    288            << "  hash:" << username_hash
    289            << "  is_primary_user:" << is_primary_user;
    290 
    291   if (!crypto::InitializeNSSForChromeOSUser(
    292            username, username_hash, is_primary_user, path)) {
    293     // If the user already exists in nss_util's map, it is already initialized
    294     // or in the process of being initialized. In either case, there's no need
    295     // to do anything.
    296     return;
    297   }
    298 
    299   if (crypto::IsTPMTokenEnabledForNSS()) {
    300     if (crypto::IsTPMTokenReady(base::Bind(
    301             &StartTPMSlotInitializationOnIOThread, username, username_hash))) {
    302       StartTPMSlotInitializationOnIOThread(username, username_hash);
    303     } else {
    304       DVLOG(1) << "Waiting for tpm ready ...";
    305     }
    306   } else {
    307     crypto::InitializePrivateSoftwareSlotForChromeOSUser(username_hash);
    308   }
    309 }
    310 #endif  // defined(OS_CHROMEOS)
    311 
    312 }  // namespace
    313 
    314 void ProfileIOData::InitializeOnUIThread(Profile* profile) {
    315   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
    316   PrefService* pref_service = profile->GetPrefs();
    317   PrefService* local_state_pref_service = g_browser_process->local_state();
    318 
    319   scoped_ptr<ProfileParams> params(new ProfileParams);
    320   params->path = profile->GetPath();
    321 
    322   params->io_thread = g_browser_process->io_thread();
    323 
    324   params->cookie_settings = CookieSettings::Factory::GetForProfile(profile);
    325   params->host_content_settings_map = profile->GetHostContentSettingsMap();
    326   params->ssl_config_service = profile->GetSSLConfigService();
    327   params->cookie_monster_delegate =
    328       chrome_browser_net::CreateCookieDelegate(profile);
    329   params->extension_info_map =
    330       extensions::ExtensionSystem::Get(profile)->info_map();
    331 
    332   ProtocolHandlerRegistry* protocol_handler_registry =
    333       ProtocolHandlerRegistryFactory::GetForProfile(profile);
    334   DCHECK(protocol_handler_registry);
    335 
    336   // The profile instance is only available here in the InitializeOnUIThread
    337   // method, so we create the url job factory here, then save it for
    338   // later delivery to the job factory in Init().
    339   params->protocol_handler_interceptor =
    340       protocol_handler_registry->CreateJobInterceptorFactory();
    341 
    342   params->proxy_config_service
    343       .reset(ProxyServiceFactory::CreateProxyConfigService(
    344            profile->GetProxyConfigTracker()));
    345 #if defined(ENABLE_MANAGED_USERS)
    346   SupervisedUserService* supervised_user_service =
    347       SupervisedUserServiceFactory::GetForProfile(profile);
    348   params->supervised_user_url_filter =
    349       supervised_user_service->GetURLFilterForIOThread();
    350 #endif
    351 #if defined(OS_CHROMEOS)
    352   chromeos::UserManager* user_manager = chromeos::UserManager::Get();
    353   if (user_manager) {
    354     chromeos::User* user = user_manager->GetUserByProfile(profile);
    355     if (user) {
    356       params->username_hash = user->username_hash();
    357       bool is_primary_user = (user_manager->GetPrimaryUser() == user);
    358       BrowserThread::PostTask(BrowserThread::IO,
    359                               FROM_HERE,
    360                               base::Bind(&StartNSSInitOnIOThread,
    361                                          user->email(),
    362                                          user->username_hash(),
    363                                          profile->GetPath(),
    364                                          is_primary_user));
    365     }
    366   }
    367   if (params->username_hash.empty())
    368     LOG(WARNING) << "no username_hash";
    369 #endif
    370 
    371   params->profile = profile;
    372   params->prerender_tracker = g_browser_process->prerender_tracker();
    373   profile_params_.reset(params.release());
    374 
    375   ChromeNetworkDelegate::InitializePrefsOnUIThread(
    376       &enable_referrers_,
    377       &enable_do_not_track_,
    378       &force_safesearch_,
    379       pref_service);
    380 
    381   scoped_refptr<base::MessageLoopProxy> io_message_loop_proxy =
    382       BrowserThread::GetMessageLoopProxyForThread(BrowserThread::IO);
    383 #if defined(ENABLE_PRINTING)
    384   printing_enabled_.Init(prefs::kPrintingEnabled, pref_service);
    385   printing_enabled_.MoveToThread(io_message_loop_proxy);
    386 #endif
    387 
    388   chrome_http_user_agent_settings_.reset(
    389       new ChromeHttpUserAgentSettings(pref_service));
    390 
    391   // These members are used only for one click sign in, which is not enabled
    392   // in incognito mode.  So no need to initialize them.
    393   if (!IsOffTheRecord()) {
    394     signin_names_.reset(new SigninNamesOnIOThread());
    395 
    396     google_services_user_account_id_.Init(
    397         prefs::kGoogleServicesUserAccountId, pref_service);
    398     google_services_user_account_id_.MoveToThread(io_message_loop_proxy);
    399 
    400     google_services_username_.Init(
    401         prefs::kGoogleServicesUsername, pref_service);
    402     google_services_username_.MoveToThread(io_message_loop_proxy);
    403 
    404     google_services_username_pattern_.Init(
    405         prefs::kGoogleServicesUsernamePattern, local_state_pref_service);
    406     google_services_username_pattern_.MoveToThread(io_message_loop_proxy);
    407 
    408     reverse_autologin_enabled_.Init(
    409         prefs::kReverseAutologinEnabled, pref_service);
    410     reverse_autologin_enabled_.MoveToThread(io_message_loop_proxy);
    411 
    412     one_click_signin_rejected_email_list_.Init(
    413         prefs::kReverseAutologinRejectedEmailList, pref_service);
    414     one_click_signin_rejected_email_list_.MoveToThread(io_message_loop_proxy);
    415 
    416     sync_disabled_.Init(sync_driver::prefs::kSyncManaged, pref_service);
    417     sync_disabled_.MoveToThread(io_message_loop_proxy);
    418 
    419     signin_allowed_.Init(prefs::kSigninAllowed, pref_service);
    420     signin_allowed_.MoveToThread(io_message_loop_proxy);
    421   }
    422 
    423   quick_check_enabled_.Init(prefs::kQuickCheckEnabled,
    424                             local_state_pref_service);
    425   quick_check_enabled_.MoveToThread(io_message_loop_proxy);
    426 
    427   media_device_id_salt_ = new MediaDeviceIDSalt(pref_service, IsOffTheRecord());
    428 
    429   network_prediction_enabled_.Init(prefs::kNetworkPredictionEnabled,
    430                                    pref_service);
    431   network_prediction_enabled_.MoveToThread(io_message_loop_proxy);
    432 
    433 #if defined(OS_CHROMEOS)
    434   cert_verifier_ = policy::PolicyCertServiceFactory::CreateForProfile(profile);
    435 #endif
    436   // The URLBlacklistManager has to be created on the UI thread to register
    437   // observers of |pref_service|, and it also has to clean up on
    438   // ShutdownOnUIThread to release these observers on the right thread.
    439   // Don't pass it in |profile_params_| to make sure it is correctly cleaned up,
    440   // in particular when this ProfileIOData isn't |initialized_| during deletion.
    441 #if defined(ENABLE_CONFIGURATION_POLICY)
    442   policy::URLBlacklist::SegmentURLCallback callback =
    443       static_cast<policy::URLBlacklist::SegmentURLCallback>(
    444           url_fixer::SegmentURL);
    445   base::SequencedWorkerPool* pool = BrowserThread::GetBlockingPool();
    446   scoped_refptr<base::SequencedTaskRunner> background_task_runner =
    447       pool->GetSequencedTaskRunner(pool->GetSequenceToken());
    448   url_blacklist_manager_.reset(
    449       new policy::URLBlacklistManager(
    450           pref_service,
    451           background_task_runner,
    452           io_message_loop_proxy,
    453           callback,
    454           base::Bind(policy::OverrideBlacklistForURL)));
    455 
    456   if (!IsOffTheRecord()) {
    457     // Add policy headers for non-incognito requests.
    458     policy::PolicyHeaderService* policy_header_service =
    459         policy::PolicyHeaderServiceFactory::GetForBrowserContext(profile);
    460     if (policy_header_service) {
    461       policy_header_helper_ = policy_header_service->CreatePolicyHeaderIOHelper(
    462           io_message_loop_proxy);
    463     }
    464   }
    465 #endif
    466 
    467   incognito_availibility_pref_.Init(
    468       prefs::kIncognitoModeAvailability, pref_service);
    469   incognito_availibility_pref_.MoveToThread(io_message_loop_proxy);
    470 
    471   initialized_on_UI_thread_ = true;
    472 
    473   // We need to make sure that content initializes its own data structures that
    474   // are associated with each ResourceContext because we might post this
    475   // object to the IO thread after this function.
    476   BrowserContext::EnsureResourceContextInitialized(profile);
    477 }
    478 
    479 ProfileIOData::MediaRequestContext::MediaRequestContext() {
    480 }
    481 
    482 void ProfileIOData::MediaRequestContext::SetHttpTransactionFactory(
    483     scoped_ptr<net::HttpTransactionFactory> http_factory) {
    484   http_factory_ = http_factory.Pass();
    485   set_http_transaction_factory(http_factory_.get());
    486 }
    487 
    488 ProfileIOData::MediaRequestContext::~MediaRequestContext() {}
    489 
    490 ProfileIOData::AppRequestContext::AppRequestContext() {
    491 }
    492 
    493 void ProfileIOData::AppRequestContext::SetCookieStore(
    494     net::CookieStore* cookie_store) {
    495   cookie_store_ = cookie_store;
    496   set_cookie_store(cookie_store);
    497 }
    498 
    499 void ProfileIOData::AppRequestContext::SetHttpTransactionFactory(
    500     scoped_ptr<net::HttpTransactionFactory> http_factory) {
    501   http_factory_ = http_factory.Pass();
    502   set_http_transaction_factory(http_factory_.get());
    503 }
    504 
    505 void ProfileIOData::AppRequestContext::SetJobFactory(
    506     scoped_ptr<net::URLRequestJobFactory> job_factory) {
    507   job_factory_ = job_factory.Pass();
    508   set_job_factory(job_factory_.get());
    509 }
    510 
    511 ProfileIOData::AppRequestContext::~AppRequestContext() {}
    512 
    513 ProfileIOData::ProfileParams::ProfileParams()
    514     : io_thread(NULL),
    515       profile(NULL) {
    516 }
    517 
    518 ProfileIOData::ProfileParams::~ProfileParams() {}
    519 
    520 ProfileIOData::ProfileIOData(Profile::ProfileType profile_type)
    521     : initialized_(false),
    522       resource_context_(new ResourceContext(this)),
    523       initialized_on_UI_thread_(false),
    524       profile_type_(profile_type) {
    525   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
    526 }
    527 
    528 ProfileIOData::~ProfileIOData() {
    529   if (BrowserThread::IsMessageLoopValid(BrowserThread::IO))
    530     DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
    531 
    532   // Pull the contents of the request context maps onto the stack for sanity
    533   // checking of values in a minidump. http://crbug.com/260425
    534   size_t num_app_contexts = app_request_context_map_.size();
    535   size_t num_media_contexts = isolated_media_request_context_map_.size();
    536   size_t current_context = 0;
    537   static const size_t kMaxCachedContexts = 20;
    538   ChromeURLRequestContext* app_context_cache[kMaxCachedContexts] = {0};
    539   void* app_context_vtable_cache[kMaxCachedContexts] = {0};
    540   ChromeURLRequestContext* media_context_cache[kMaxCachedContexts] = {0};
    541   void* media_context_vtable_cache[kMaxCachedContexts] = {0};
    542   void* tmp_vtable = NULL;
    543   base::debug::Alias(&num_app_contexts);
    544   base::debug::Alias(&num_media_contexts);
    545   base::debug::Alias(&current_context);
    546   base::debug::Alias(app_context_cache);
    547   base::debug::Alias(app_context_vtable_cache);
    548   base::debug::Alias(media_context_cache);
    549   base::debug::Alias(media_context_vtable_cache);
    550   base::debug::Alias(&tmp_vtable);
    551 
    552   current_context = 0;
    553   for (URLRequestContextMap::const_iterator it =
    554            app_request_context_map_.begin();
    555        current_context < kMaxCachedContexts &&
    556            it != app_request_context_map_.end();
    557        ++it, ++current_context) {
    558     app_context_cache[current_context] = it->second;
    559     memcpy(&app_context_vtable_cache[current_context],
    560            static_cast<void*>(it->second), sizeof(void*));
    561   }
    562 
    563   current_context = 0;
    564   for (URLRequestContextMap::const_iterator it =
    565            isolated_media_request_context_map_.begin();
    566        current_context < kMaxCachedContexts &&
    567            it != isolated_media_request_context_map_.end();
    568        ++it, ++current_context) {
    569     media_context_cache[current_context] = it->second;
    570     memcpy(&media_context_vtable_cache[current_context],
    571            static_cast<void*>(it->second), sizeof(void*));
    572   }
    573 
    574   // TODO(ajwong): These AssertNoURLRequests() calls are unnecessary since they
    575   // are already done in the URLRequestContext destructor.
    576   if (main_request_context_)
    577     main_request_context_->AssertNoURLRequests();
    578   if (extensions_request_context_)
    579     extensions_request_context_->AssertNoURLRequests();
    580 
    581   current_context = 0;
    582   for (URLRequestContextMap::iterator it = app_request_context_map_.begin();
    583        it != app_request_context_map_.end(); ++it) {
    584     if (current_context < kMaxCachedContexts) {
    585       CHECK_EQ(app_context_cache[current_context], it->second);
    586       memcpy(&tmp_vtable, static_cast<void*>(it->second), sizeof(void*));
    587       CHECK_EQ(app_context_vtable_cache[current_context], tmp_vtable);
    588     }
    589     it->second->AssertNoURLRequests();
    590     delete it->second;
    591     current_context++;
    592   }
    593 
    594   current_context = 0;
    595   for (URLRequestContextMap::iterator it =
    596            isolated_media_request_context_map_.begin();
    597        it != isolated_media_request_context_map_.end(); ++it) {
    598     if (current_context < kMaxCachedContexts) {
    599       CHECK_EQ(media_context_cache[current_context], it->second);
    600       memcpy(&tmp_vtable, static_cast<void*>(it->second), sizeof(void*));
    601       CHECK_EQ(media_context_vtable_cache[current_context], tmp_vtable);
    602     }
    603     it->second->AssertNoURLRequests();
    604     delete it->second;
    605     current_context++;
    606   }
    607 }
    608 
    609 // static
    610 ProfileIOData* ProfileIOData::FromResourceContext(
    611     content::ResourceContext* rc) {
    612   return (static_cast<ResourceContext*>(rc))->io_data_;
    613 }
    614 
    615 // static
    616 bool ProfileIOData::IsHandledProtocol(const std::string& scheme) {
    617   DCHECK_EQ(scheme, StringToLowerASCII(scheme));
    618   static const char* const kProtocolList[] = {
    619     url::kFileScheme,
    620     content::kChromeDevToolsScheme,
    621     chrome::kDomDistillerScheme,
    622     extensions::kExtensionScheme,
    623     extensions::kExtensionResourceScheme,
    624     content::kChromeUIScheme,
    625     url::kDataScheme,
    626 #if defined(OS_CHROMEOS)
    627     chrome::kDriveScheme,
    628 #endif  // defined(OS_CHROMEOS)
    629     url::kAboutScheme,
    630 #if !defined(DISABLE_FTP_SUPPORT)
    631     url::kFtpScheme,
    632 #endif  // !defined(DISABLE_FTP_SUPPORT)
    633     url::kBlobScheme,
    634     url::kFileSystemScheme,
    635     chrome::kChromeSearchScheme,
    636   };
    637   for (size_t i = 0; i < arraysize(kProtocolList); ++i) {
    638     if (scheme == kProtocolList[i])
    639       return true;
    640   }
    641   return net::URLRequest::IsHandledProtocol(scheme);
    642 }
    643 
    644 // static
    645 bool ProfileIOData::IsHandledURL(const GURL& url) {
    646   if (!url.is_valid()) {
    647     // We handle error cases.
    648     return true;
    649   }
    650 
    651   return IsHandledProtocol(url.scheme());
    652 }
    653 
    654 // static
    655 void ProfileIOData::InstallProtocolHandlers(
    656     net::URLRequestJobFactoryImpl* job_factory,
    657     content::ProtocolHandlerMap* protocol_handlers) {
    658   for (content::ProtocolHandlerMap::iterator it =
    659            protocol_handlers->begin();
    660        it != protocol_handlers->end();
    661        ++it) {
    662     bool set_protocol = job_factory->SetProtocolHandler(
    663         it->first, it->second.release());
    664     DCHECK(set_protocol);
    665   }
    666   protocol_handlers->clear();
    667 }
    668 
    669 content::ResourceContext* ProfileIOData::GetResourceContext() const {
    670   return resource_context_.get();
    671 }
    672 
    673 ChromeURLRequestContext* ProfileIOData::GetMainRequestContext() const {
    674   DCHECK(initialized_);
    675   return main_request_context_.get();
    676 }
    677 
    678 ChromeURLRequestContext* ProfileIOData::GetMediaRequestContext() const {
    679   DCHECK(initialized_);
    680   ChromeURLRequestContext* context = AcquireMediaRequestContext();
    681   DCHECK(context);
    682   return context;
    683 }
    684 
    685 ChromeURLRequestContext* ProfileIOData::GetExtensionsRequestContext() const {
    686   DCHECK(initialized_);
    687   return extensions_request_context_.get();
    688 }
    689 
    690 ChromeURLRequestContext* ProfileIOData::GetIsolatedAppRequestContext(
    691     ChromeURLRequestContext* main_context,
    692     const StoragePartitionDescriptor& partition_descriptor,
    693     scoped_ptr<ProtocolHandlerRegistry::JobInterceptorFactory>
    694         protocol_handler_interceptor,
    695     content::ProtocolHandlerMap* protocol_handlers,
    696     content::URLRequestInterceptorScopedVector request_interceptors) const {
    697   DCHECK(initialized_);
    698   ChromeURLRequestContext* context = NULL;
    699   if (ContainsKey(app_request_context_map_, partition_descriptor)) {
    700     context = app_request_context_map_[partition_descriptor];
    701   } else {
    702     context =
    703         AcquireIsolatedAppRequestContext(main_context,
    704                                          partition_descriptor,
    705                                          protocol_handler_interceptor.Pass(),
    706                                          protocol_handlers,
    707                                          request_interceptors.Pass());
    708     app_request_context_map_[partition_descriptor] = context;
    709   }
    710   DCHECK(context);
    711   return context;
    712 }
    713 
    714 ChromeURLRequestContext* ProfileIOData::GetIsolatedMediaRequestContext(
    715     ChromeURLRequestContext* app_context,
    716     const StoragePartitionDescriptor& partition_descriptor) const {
    717   DCHECK(initialized_);
    718   ChromeURLRequestContext* context = NULL;
    719   if (ContainsKey(isolated_media_request_context_map_, partition_descriptor)) {
    720     context = isolated_media_request_context_map_[partition_descriptor];
    721   } else {
    722     context = AcquireIsolatedMediaRequestContext(app_context,
    723                                                  partition_descriptor);
    724     isolated_media_request_context_map_[partition_descriptor] = context;
    725   }
    726   DCHECK(context);
    727   return context;
    728 }
    729 
    730 extensions::InfoMap* ProfileIOData::GetExtensionInfoMap() const {
    731   DCHECK(initialized_) << "ExtensionSystem not initialized";
    732   return extension_info_map_.get();
    733 }
    734 
    735 CookieSettings* ProfileIOData::GetCookieSettings() const {
    736   // Allow either Init() or SetCookieSettingsForTesting() to initialize.
    737   DCHECK(initialized_ || cookie_settings_.get());
    738   return cookie_settings_.get();
    739 }
    740 
    741 HostContentSettingsMap* ProfileIOData::GetHostContentSettingsMap() const {
    742   DCHECK(initialized_);
    743   return host_content_settings_map_.get();
    744 }
    745 
    746 ResourceContext::SaltCallback ProfileIOData::GetMediaDeviceIDSalt() const {
    747   return base::Bind(&MediaDeviceIDSalt::GetSalt, media_device_id_salt_);
    748 }
    749 
    750 bool ProfileIOData::IsOffTheRecord() const {
    751   return profile_type() == Profile::INCOGNITO_PROFILE
    752       || profile_type() == Profile::GUEST_PROFILE;
    753 }
    754 
    755 void ProfileIOData::InitializeMetricsEnabledStateOnUIThread() {
    756   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
    757 #if defined(OS_CHROMEOS)
    758   // Just fetch the value from ChromeOS' settings while we're on the UI thread.
    759   // TODO(stevet): For now, this value is only set on profile initialization.
    760   // We will want to do something similar to the PrefMember method below in the
    761   // future to more accurately capture this state.
    762   chromeos::CrosSettings::Get()->GetBoolean(chromeos::kStatsReportingPref,
    763                                             &enable_metrics_);
    764 #elif defined(OS_ANDROID)
    765   // TODO(dwkang): rename or unify the pref for UMA once we have conclusion
    766   // in crbugs.com/246495.
    767   // Android has it's own preferences for metrics / crash uploading.
    768   enable_metrics_.Init(prefs::kCrashReportingEnabled,
    769                        g_browser_process->local_state());
    770   enable_metrics_.MoveToThread(
    771       BrowserThread::GetMessageLoopProxyForThread(BrowserThread::IO));
    772 #else
    773   // Prep the PrefMember and send it to the IO thread, since this value will be
    774   // read from there.
    775   enable_metrics_.Init(prefs::kMetricsReportingEnabled,
    776                        g_browser_process->local_state());
    777   enable_metrics_.MoveToThread(
    778       BrowserThread::GetMessageLoopProxyForThread(BrowserThread::IO));
    779 #endif  // defined(OS_CHROMEOS)
    780 }
    781 
    782 bool ProfileIOData::GetMetricsEnabledStateOnIOThread() const {
    783   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
    784 #if defined(OS_CHROMEOS)
    785   return enable_metrics_;
    786 #else
    787   return enable_metrics_.GetValue();
    788 #endif  // defined(OS_CHROMEOS)
    789 }
    790 
    791 base::WeakPtr<net::HttpServerProperties>
    792 ProfileIOData::http_server_properties() const {
    793   return http_server_properties_->GetWeakPtr();
    794 }
    795 
    796 void ProfileIOData::set_http_server_properties(
    797     scoped_ptr<net::HttpServerProperties> http_server_properties) const {
    798   http_server_properties_ = http_server_properties.Pass();
    799 }
    800 
    801 ProfileIOData::ResourceContext::ResourceContext(ProfileIOData* io_data)
    802     : io_data_(io_data),
    803       host_resolver_(NULL),
    804       request_context_(NULL) {
    805   DCHECK(io_data);
    806 }
    807 
    808 ProfileIOData::ResourceContext::~ResourceContext() {}
    809 
    810 net::HostResolver* ProfileIOData::ResourceContext::GetHostResolver()  {
    811   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
    812   DCHECK(io_data_->initialized_);
    813   return host_resolver_;
    814 }
    815 
    816 net::URLRequestContext* ProfileIOData::ResourceContext::GetRequestContext()  {
    817   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
    818   DCHECK(io_data_->initialized_);
    819   return request_context_;
    820 }
    821 
    822 scoped_ptr<net::ClientCertStore>
    823 ProfileIOData::ResourceContext::CreateClientCertStore() {
    824   if (!io_data_->client_cert_store_factory_.is_null())
    825     return io_data_->client_cert_store_factory_.Run();
    826 #if defined(OS_CHROMEOS)
    827   return scoped_ptr<net::ClientCertStore>(new net::ClientCertStoreChromeOS(
    828       io_data_->username_hash(),
    829       base::Bind(&CreateCryptoModuleBlockingPasswordDelegate,
    830                  chrome::kCryptoModulePasswordClientAuth)));
    831 #elif defined(USE_NSS)
    832   return scoped_ptr<net::ClientCertStore>(new net::ClientCertStoreNSS(
    833       base::Bind(&CreateCryptoModuleBlockingPasswordDelegate,
    834                  chrome::kCryptoModulePasswordClientAuth)));
    835 #elif defined(OS_WIN)
    836   return scoped_ptr<net::ClientCertStore>(new net::ClientCertStoreWin());
    837 #elif defined(OS_MACOSX)
    838   return scoped_ptr<net::ClientCertStore>(new net::ClientCertStoreMac());
    839 #elif defined(USE_OPENSSL)
    840   // OpenSSL does not use the ClientCertStore infrastructure. On Android client
    841   // cert matching is done by the OS as part of the call to show the cert
    842   // selection dialog.
    843   return scoped_ptr<net::ClientCertStore>();
    844 #else
    845 #error Unknown platform.
    846 #endif
    847 }
    848 
    849 void ProfileIOData::ResourceContext::CreateKeygenHandler(
    850     uint32 key_size_in_bits,
    851     const std::string& challenge_string,
    852     const GURL& url,
    853     const base::Callback<void(scoped_ptr<net::KeygenHandler>)>& callback) {
    854   DCHECK(!callback.is_null());
    855 #if defined(USE_NSS)
    856   scoped_ptr<net::KeygenHandler> keygen_handler(
    857       new net::KeygenHandler(key_size_in_bits, challenge_string, url));
    858 
    859   scoped_ptr<ChromeNSSCryptoModuleDelegate> delegate(
    860       new ChromeNSSCryptoModuleDelegate(chrome::kCryptoModulePasswordKeygen,
    861                                         net::HostPortPair::FromURL(url)));
    862   ChromeNSSCryptoModuleDelegate* delegate_ptr = delegate.get();
    863   keygen_handler->set_crypto_module_delegate(
    864       delegate.PassAs<crypto::NSSCryptoModuleDelegate>());
    865 
    866   base::Closure bound_callback =
    867       base::Bind(callback, base::Passed(&keygen_handler));
    868   if (delegate_ptr->InitializeSlot(this, bound_callback)) {
    869     // Initialization complete, run the callback synchronously.
    870     bound_callback.Run();
    871     return;
    872   }
    873   // Otherwise, the InitializeSlot will run the callback asynchronously.
    874 #else
    875   callback.Run(make_scoped_ptr(
    876       new net::KeygenHandler(key_size_in_bits, challenge_string, url)));
    877 #endif
    878 }
    879 
    880 bool ProfileIOData::ResourceContext::AllowMicAccess(const GURL& origin) {
    881   return AllowContentAccess(origin, CONTENT_SETTINGS_TYPE_MEDIASTREAM_MIC);
    882 }
    883 
    884 bool ProfileIOData::ResourceContext::AllowCameraAccess(const GURL& origin) {
    885   return AllowContentAccess(origin, CONTENT_SETTINGS_TYPE_MEDIASTREAM_CAMERA);
    886 }
    887 
    888 bool ProfileIOData::ResourceContext::AllowContentAccess(
    889     const GURL& origin, ContentSettingsType type) {
    890   HostContentSettingsMap* content_settings =
    891       io_data_->GetHostContentSettingsMap();
    892   ContentSetting setting = content_settings->GetContentSetting(
    893       origin, origin, type, NO_RESOURCE_IDENTIFIER);
    894   return setting == CONTENT_SETTING_ALLOW;
    895 }
    896 
    897 ResourceContext::SaltCallback
    898 ProfileIOData::ResourceContext::GetMediaDeviceIDSalt() {
    899   return io_data_->GetMediaDeviceIDSalt();
    900 }
    901 
    902 // static
    903 std::string ProfileIOData::GetSSLSessionCacheShard() {
    904   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
    905   // The SSL session cache is partitioned by setting a string. This returns a
    906   // unique string to partition the SSL session cache. Each time we create a
    907   // new profile, we'll get a fresh SSL session cache which is separate from
    908   // the other profiles.
    909   static unsigned ssl_session_cache_instance = 0;
    910   return base::StringPrintf("profile/%u", ssl_session_cache_instance++);
    911 }
    912 
    913 void ProfileIOData::Init(
    914     content::ProtocolHandlerMap* protocol_handlers,
    915     content::URLRequestInterceptorScopedVector request_interceptors) const {
    916   // The basic logic is implemented here. The specific initialization
    917   // is done in InitializeInternal(), implemented by subtypes. Static helper
    918   // functions have been provided to assist in common operations.
    919   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
    920   DCHECK(!initialized_);
    921 
    922   startup_metric_utils::ScopedSlowStartupUMA
    923       scoped_timer("Startup.SlowStartupProfileIODataInit");
    924 
    925   // TODO(jhawkins): Remove once crbug.com/102004 is fixed.
    926   CHECK(initialized_on_UI_thread_);
    927 
    928   // TODO(jhawkins): Return to DCHECK once crbug.com/102004 is fixed.
    929   CHECK(profile_params_.get());
    930 
    931   IOThread* const io_thread = profile_params_->io_thread;
    932   IOThread::Globals* const io_thread_globals = io_thread->globals();
    933   const CommandLine& command_line = *CommandLine::ForCurrentProcess();
    934 
    935   // Create the common request contexts.
    936   main_request_context_.reset(new ChromeURLRequestContext());
    937   extensions_request_context_.reset(new ChromeURLRequestContext());
    938 
    939   ChromeNetworkDelegate* network_delegate =
    940       new ChromeNetworkDelegate(
    941           io_thread_globals->extension_event_router_forwarder.get(),
    942           &enable_referrers_);
    943   network_delegate->set_data_reduction_proxy_params(
    944       io_thread_globals->data_reduction_proxy_params.get());
    945   if (command_line.HasSwitch(switches::kEnableClientHints))
    946     network_delegate->SetEnableClientHints();
    947   network_delegate->set_extension_info_map(
    948       profile_params_->extension_info_map.get());
    949 #if defined(ENABLE_CONFIGURATION_POLICY)
    950   network_delegate->set_url_blacklist_manager(url_blacklist_manager_.get());
    951 #endif
    952   network_delegate->set_profile(profile_params_->profile);
    953   network_delegate->set_profile_path(profile_params_->path);
    954   network_delegate->set_cookie_settings(profile_params_->cookie_settings.get());
    955   network_delegate->set_enable_do_not_track(&enable_do_not_track_);
    956   network_delegate->set_force_google_safe_search(&force_safesearch_);
    957   network_delegate->set_prerender_tracker(profile_params_->prerender_tracker);
    958   network_delegate_.reset(network_delegate);
    959 
    960   fraudulent_certificate_reporter_.reset(
    961       new chrome_browser_net::ChromeFraudulentCertificateReporter(
    962           main_request_context_.get()));
    963 
    964   // NOTE: Proxy service uses the default io thread network delegate, not the
    965   // delegate just created.
    966   proxy_service_.reset(
    967       ProxyServiceFactory::CreateProxyService(
    968           io_thread->net_log(),
    969           io_thread_globals->proxy_script_fetcher_context.get(),
    970           io_thread_globals->system_network_delegate.get(),
    971           profile_params_->proxy_config_service.release(),
    972           command_line,
    973           quick_check_enabled_.GetValue()));
    974 
    975   transport_security_state_.reset(new net::TransportSecurityState());
    976   transport_security_persister_.reset(
    977       new net::TransportSecurityPersister(
    978           transport_security_state_.get(),
    979           profile_params_->path,
    980           BrowserThread::GetMessageLoopProxyForThread(BrowserThread::FILE),
    981           IsOffTheRecord()));
    982 
    983   // Take ownership over these parameters.
    984   cookie_settings_ = profile_params_->cookie_settings;
    985   host_content_settings_map_ = profile_params_->host_content_settings_map;
    986   extension_info_map_ = profile_params_->extension_info_map;
    987 
    988   resource_context_->host_resolver_ = io_thread_globals->host_resolver.get();
    989   resource_context_->request_context_ = main_request_context_.get();
    990 
    991 #if defined(ENABLE_MANAGED_USERS)
    992   supervised_user_url_filter_ = profile_params_->supervised_user_url_filter;
    993 #endif
    994 
    995 #if defined(OS_CHROMEOS)
    996   username_hash_ = profile_params_->username_hash;
    997   scoped_refptr<net::CertVerifyProc> verify_proc;
    998   crypto::ScopedPK11Slot public_slot =
    999       crypto::GetPublicSlotForChromeOSUser(username_hash_);
   1000   // The private slot won't be ready by this point. It shouldn't be necessary
   1001   // for cert trust purposes anyway.
   1002   verify_proc = new chromeos::CertVerifyProcChromeOS(public_slot.Pass());
   1003   if (cert_verifier_) {
   1004     cert_verifier_->InitializeOnIOThread(verify_proc);
   1005     main_request_context_->set_cert_verifier(cert_verifier_.get());
   1006   } else {
   1007     main_request_context_->set_cert_verifier(
   1008         new net::MultiThreadedCertVerifier(verify_proc.get()));
   1009   }
   1010 #else
   1011   main_request_context_->set_cert_verifier(
   1012       io_thread_globals->cert_verifier.get());
   1013 #endif
   1014 
   1015   InitializeInternal(
   1016       profile_params_.get(), protocol_handlers, request_interceptors.Pass());
   1017 
   1018   profile_params_.reset();
   1019   initialized_ = true;
   1020 }
   1021 
   1022 void ProfileIOData::ApplyProfileParamsToContext(
   1023     ChromeURLRequestContext* context) const {
   1024   context->set_http_user_agent_settings(
   1025       chrome_http_user_agent_settings_.get());
   1026   context->set_ssl_config_service(profile_params_->ssl_config_service.get());
   1027 }
   1028 
   1029 scoped_ptr<net::URLRequestJobFactory> ProfileIOData::SetUpJobFactoryDefaults(
   1030     scoped_ptr<net::URLRequestJobFactoryImpl> job_factory,
   1031     content::URLRequestInterceptorScopedVector request_interceptors,
   1032     scoped_ptr<ProtocolHandlerRegistry::JobInterceptorFactory>
   1033         protocol_handler_interceptor,
   1034     net::NetworkDelegate* network_delegate,
   1035     net::FtpTransactionFactory* ftp_transaction_factory) const {
   1036   // NOTE(willchan): Keep these protocol handlers in sync with
   1037   // ProfileIOData::IsHandledProtocol().
   1038   bool set_protocol = job_factory->SetProtocolHandler(
   1039       url::kFileScheme,
   1040       new net::FileProtocolHandler(
   1041           content::BrowserThread::GetBlockingPool()->
   1042               GetTaskRunnerWithShutdownBehavior(
   1043                   base::SequencedWorkerPool::SKIP_ON_SHUTDOWN)));
   1044   DCHECK(set_protocol);
   1045 
   1046   DCHECK(extension_info_map_.get());
   1047   // Check only for incognito (and not Chrome OS guest mode GUEST_PROFILE).
   1048   bool is_incognito = profile_type() == Profile::INCOGNITO_PROFILE;
   1049   set_protocol = job_factory->SetProtocolHandler(
   1050       extensions::kExtensionScheme,
   1051       extensions::CreateExtensionProtocolHandler(is_incognito,
   1052                                                  extension_info_map_.get()));
   1053   DCHECK(set_protocol);
   1054   set_protocol = job_factory->SetProtocolHandler(
   1055       extensions::kExtensionResourceScheme,
   1056       CreateExtensionResourceProtocolHandler());
   1057   DCHECK(set_protocol);
   1058   set_protocol = job_factory->SetProtocolHandler(
   1059       url::kDataScheme, new net::DataProtocolHandler());
   1060   DCHECK(set_protocol);
   1061 #if defined(OS_CHROMEOS)
   1062   if (profile_params_) {
   1063     set_protocol = job_factory->SetProtocolHandler(
   1064         chrome::kDriveScheme,
   1065         new drive::DriveProtocolHandler(profile_params_->profile));
   1066     DCHECK(set_protocol);
   1067   }
   1068 #endif  // defined(OS_CHROMEOS)
   1069 
   1070   job_factory->SetProtocolHandler(
   1071       url::kAboutScheme, new chrome_browser_net::AboutProtocolHandler());
   1072 #if !defined(DISABLE_FTP_SUPPORT)
   1073   DCHECK(ftp_transaction_factory);
   1074   job_factory->SetProtocolHandler(
   1075       url::kFtpScheme,
   1076       new net::FtpProtocolHandler(ftp_transaction_factory));
   1077 #endif  // !defined(DISABLE_FTP_SUPPORT)
   1078 
   1079 #if defined(DEBUG_DEVTOOLS)
   1080   request_interceptors.push_back(new DebugDevToolsInterceptor);
   1081 #endif
   1082 
   1083   // Set up interceptors in the reverse order.
   1084   scoped_ptr<net::URLRequestJobFactory> top_job_factory =
   1085       job_factory.PassAs<net::URLRequestJobFactory>();
   1086   for (content::URLRequestInterceptorScopedVector::reverse_iterator i =
   1087            request_interceptors.rbegin();
   1088        i != request_interceptors.rend();
   1089        ++i) {
   1090     top_job_factory.reset(new net::URLRequestInterceptingJobFactory(
   1091         top_job_factory.Pass(), make_scoped_ptr(*i)));
   1092   }
   1093   request_interceptors.weak_clear();
   1094 
   1095   if (protocol_handler_interceptor) {
   1096     protocol_handler_interceptor->Chain(top_job_factory.Pass());
   1097     return protocol_handler_interceptor.PassAs<net::URLRequestJobFactory>();
   1098   } else {
   1099     return top_job_factory.Pass();
   1100   }
   1101 }
   1102 
   1103 void ProfileIOData::ShutdownOnUIThread() {
   1104   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   1105 
   1106   if (signin_names_)
   1107     signin_names_->ReleaseResourcesOnUIThread();
   1108 
   1109   google_services_user_account_id_.Destroy();
   1110   google_services_username_.Destroy();
   1111   google_services_username_pattern_.Destroy();
   1112   reverse_autologin_enabled_.Destroy();
   1113   one_click_signin_rejected_email_list_.Destroy();
   1114   enable_referrers_.Destroy();
   1115   enable_do_not_track_.Destroy();
   1116   force_safesearch_.Destroy();
   1117 #if !defined(OS_CHROMEOS)
   1118   enable_metrics_.Destroy();
   1119 #endif
   1120   safe_browsing_enabled_.Destroy();
   1121   data_reduction_proxy_enabled_.Destroy();
   1122   printing_enabled_.Destroy();
   1123   sync_disabled_.Destroy();
   1124   signin_allowed_.Destroy();
   1125   network_prediction_enabled_.Destroy();
   1126   quick_check_enabled_.Destroy();
   1127   if (media_device_id_salt_)
   1128     media_device_id_salt_->ShutdownOnUIThread();
   1129   session_startup_pref_.Destroy();
   1130 #if defined(ENABLE_CONFIGURATION_POLICY)
   1131   if (url_blacklist_manager_)
   1132     url_blacklist_manager_->ShutdownOnUIThread();
   1133 #endif
   1134   if (chrome_http_user_agent_settings_)
   1135     chrome_http_user_agent_settings_->CleanupOnUIThread();
   1136   incognito_availibility_pref_.Destroy();
   1137   bool posted = BrowserThread::DeleteSoon(BrowserThread::IO, FROM_HERE, this);
   1138   if (!posted)
   1139     delete this;
   1140 }
   1141 
   1142 void ProfileIOData::set_server_bound_cert_service(
   1143     net::ServerBoundCertService* server_bound_cert_service) const {
   1144   server_bound_cert_service_.reset(server_bound_cert_service);
   1145 }
   1146 
   1147 void ProfileIOData::DestroyResourceContext() {
   1148   resource_context_.reset();
   1149 }
   1150 
   1151 scoped_ptr<net::HttpCache> ProfileIOData::CreateMainHttpFactory(
   1152     const ProfileParams* profile_params,
   1153     net::HttpCache::BackendFactory* main_backend) const {
   1154   net::HttpNetworkSession::Params params;
   1155   ChromeURLRequestContext* context = main_request_context();
   1156 
   1157   IOThread* const io_thread = profile_params->io_thread;
   1158 
   1159   io_thread->InitializeNetworkSessionParams(&params);
   1160 
   1161   params.host_resolver = context->host_resolver();
   1162   params.cert_verifier = context->cert_verifier();
   1163   params.server_bound_cert_service = context->server_bound_cert_service();
   1164   params.transport_security_state = context->transport_security_state();
   1165   params.cert_transparency_verifier = context->cert_transparency_verifier();
   1166   params.proxy_service = context->proxy_service();
   1167   params.ssl_session_cache_shard = GetSSLSessionCacheShard();
   1168   params.ssl_config_service = context->ssl_config_service();
   1169   params.http_auth_handler_factory = context->http_auth_handler_factory();
   1170   params.network_delegate = network_delegate();
   1171   params.http_server_properties = context->http_server_properties();
   1172   params.net_log = context->net_log();
   1173 
   1174   network_controller_.reset(new DevToolsNetworkController());
   1175 
   1176   net::HttpNetworkSession* session = new net::HttpNetworkSession(params);
   1177   return scoped_ptr<net::HttpCache>(new net::HttpCache(
   1178       new DevToolsNetworkTransactionFactory(network_controller_.get(), session),
   1179       context->net_log(), main_backend));
   1180 }
   1181 
   1182 scoped_ptr<net::HttpCache> ProfileIOData::CreateHttpFactory(
   1183     net::HttpNetworkSession* shared_session,
   1184     net::HttpCache::BackendFactory* backend) const {
   1185   return scoped_ptr<net::HttpCache>(new net::HttpCache(
   1186       new DevToolsNetworkTransactionFactory(
   1187           network_controller_.get(), shared_session),
   1188       shared_session->net_log(), backend));
   1189 }
   1190 
   1191 void ProfileIOData::SetCookieSettingsForTesting(
   1192     CookieSettings* cookie_settings) {
   1193   DCHECK(!cookie_settings_.get());
   1194   cookie_settings_ = cookie_settings;
   1195 }
   1196 
   1197 void ProfileIOData::set_signin_names_for_testing(
   1198     SigninNamesOnIOThread* signin_names) {
   1199   signin_names_.reset(signin_names);
   1200 }
   1201