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)
IsSupportedDevToolsURL(const GURL & url,base::FilePath * path)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:
DebugDevToolsInterceptor()186 DebugDevToolsInterceptor() {}
~DebugDevToolsInterceptor()187 virtual ~DebugDevToolsInterceptor() {}
188
189 // net::URLRequestInterceptor implementation.
MaybeInterceptRequest(net::URLRequest * request,net::NetworkDelegate * network_delegate) const190 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
DidGetTPMInfoForUserOnUIThread(const std::string & username_hash,chromeos::DBusMethodCallStatus call_status,const std::string & label,const std::string & user_pin,int slot_id)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
GetTPMInfoForUserOnUIThread(const std::string & username,const std::string & username_hash)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
StartTPMSlotInitializationOnIOThread(const std::string & username,const std::string & username_hash)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
StartNSSInitOnIOThread(const std::string & username,const std::string & username_hash,const base::FilePath & path,bool is_primary_user)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
InitializeOnUIThread(Profile * profile)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
MediaRequestContext()479 ProfileIOData::MediaRequestContext::MediaRequestContext() {
480 }
481
SetHttpTransactionFactory(scoped_ptr<net::HttpTransactionFactory> http_factory)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
~MediaRequestContext()488 ProfileIOData::MediaRequestContext::~MediaRequestContext() {}
489
AppRequestContext()490 ProfileIOData::AppRequestContext::AppRequestContext() {
491 }
492
SetCookieStore(net::CookieStore * cookie_store)493 void ProfileIOData::AppRequestContext::SetCookieStore(
494 net::CookieStore* cookie_store) {
495 cookie_store_ = cookie_store;
496 set_cookie_store(cookie_store);
497 }
498
SetHttpTransactionFactory(scoped_ptr<net::HttpTransactionFactory> http_factory)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
SetJobFactory(scoped_ptr<net::URLRequestJobFactory> job_factory)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
~AppRequestContext()511 ProfileIOData::AppRequestContext::~AppRequestContext() {}
512
ProfileParams()513 ProfileIOData::ProfileParams::ProfileParams()
514 : io_thread(NULL),
515 profile(NULL) {
516 }
517
~ProfileParams()518 ProfileIOData::ProfileParams::~ProfileParams() {}
519
ProfileIOData(Profile::ProfileType profile_type)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
~ProfileIOData()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(¤t_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
FromResourceContext(content::ResourceContext * rc)610 ProfileIOData* ProfileIOData::FromResourceContext(
611 content::ResourceContext* rc) {
612 return (static_cast<ResourceContext*>(rc))->io_data_;
613 }
614
615 // static
IsHandledProtocol(const std::string & scheme)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
IsHandledURL(const GURL & url)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
InstallProtocolHandlers(net::URLRequestJobFactoryImpl * job_factory,content::ProtocolHandlerMap * protocol_handlers)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
GetResourceContext() const669 content::ResourceContext* ProfileIOData::GetResourceContext() const {
670 return resource_context_.get();
671 }
672
GetMainRequestContext() const673 ChromeURLRequestContext* ProfileIOData::GetMainRequestContext() const {
674 DCHECK(initialized_);
675 return main_request_context_.get();
676 }
677
GetMediaRequestContext() const678 ChromeURLRequestContext* ProfileIOData::GetMediaRequestContext() const {
679 DCHECK(initialized_);
680 ChromeURLRequestContext* context = AcquireMediaRequestContext();
681 DCHECK(context);
682 return context;
683 }
684
GetExtensionsRequestContext() const685 ChromeURLRequestContext* ProfileIOData::GetExtensionsRequestContext() const {
686 DCHECK(initialized_);
687 return extensions_request_context_.get();
688 }
689
GetIsolatedAppRequestContext(ChromeURLRequestContext * main_context,const StoragePartitionDescriptor & partition_descriptor,scoped_ptr<ProtocolHandlerRegistry::JobInterceptorFactory> protocol_handler_interceptor,content::ProtocolHandlerMap * protocol_handlers,content::URLRequestInterceptorScopedVector request_interceptors) const690 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
GetIsolatedMediaRequestContext(ChromeURLRequestContext * app_context,const StoragePartitionDescriptor & partition_descriptor) const714 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
GetExtensionInfoMap() const730 extensions::InfoMap* ProfileIOData::GetExtensionInfoMap() const {
731 DCHECK(initialized_) << "ExtensionSystem not initialized";
732 return extension_info_map_.get();
733 }
734
GetCookieSettings() const735 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
GetHostContentSettingsMap() const741 HostContentSettingsMap* ProfileIOData::GetHostContentSettingsMap() const {
742 DCHECK(initialized_);
743 return host_content_settings_map_.get();
744 }
745
GetMediaDeviceIDSalt() const746 ResourceContext::SaltCallback ProfileIOData::GetMediaDeviceIDSalt() const {
747 return base::Bind(&MediaDeviceIDSalt::GetSalt, media_device_id_salt_);
748 }
749
IsOffTheRecord() const750 bool ProfileIOData::IsOffTheRecord() const {
751 return profile_type() == Profile::INCOGNITO_PROFILE
752 || profile_type() == Profile::GUEST_PROFILE;
753 }
754
InitializeMetricsEnabledStateOnUIThread()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
GetMetricsEnabledStateOnIOThread() const782 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>
http_server_properties() const792 ProfileIOData::http_server_properties() const {
793 return http_server_properties_->GetWeakPtr();
794 }
795
set_http_server_properties(scoped_ptr<net::HttpServerProperties> http_server_properties) const796 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
ResourceContext(ProfileIOData * io_data)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
~ResourceContext()808 ProfileIOData::ResourceContext::~ResourceContext() {}
809
GetHostResolver()810 net::HostResolver* ProfileIOData::ResourceContext::GetHostResolver() {
811 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
812 DCHECK(io_data_->initialized_);
813 return host_resolver_;
814 }
815
GetRequestContext()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>
CreateClientCertStore()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
CreateKeygenHandler(uint32 key_size_in_bits,const std::string & challenge_string,const GURL & url,const base::Callback<void (scoped_ptr<net::KeygenHandler>)> & callback)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
AllowMicAccess(const GURL & origin)880 bool ProfileIOData::ResourceContext::AllowMicAccess(const GURL& origin) {
881 return AllowContentAccess(origin, CONTENT_SETTINGS_TYPE_MEDIASTREAM_MIC);
882 }
883
AllowCameraAccess(const GURL & origin)884 bool ProfileIOData::ResourceContext::AllowCameraAccess(const GURL& origin) {
885 return AllowContentAccess(origin, CONTENT_SETTINGS_TYPE_MEDIASTREAM_CAMERA);
886 }
887
AllowContentAccess(const GURL & origin,ContentSettingsType type)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
GetMediaDeviceIDSalt()898 ProfileIOData::ResourceContext::GetMediaDeviceIDSalt() {
899 return io_data_->GetMediaDeviceIDSalt();
900 }
901
902 // static
GetSSLSessionCacheShard()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
Init(content::ProtocolHandlerMap * protocol_handlers,content::URLRequestInterceptorScopedVector request_interceptors) const913 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
ApplyProfileParamsToContext(ChromeURLRequestContext * context) const1022 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
SetUpJobFactoryDefaults(scoped_ptr<net::URLRequestJobFactoryImpl> job_factory,content::URLRequestInterceptorScopedVector request_interceptors,scoped_ptr<ProtocolHandlerRegistry::JobInterceptorFactory> protocol_handler_interceptor,net::NetworkDelegate * network_delegate,net::FtpTransactionFactory * ftp_transaction_factory) const1029 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
ShutdownOnUIThread()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
set_server_bound_cert_service(net::ServerBoundCertService * server_bound_cert_service) const1142 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
DestroyResourceContext()1147 void ProfileIOData::DestroyResourceContext() {
1148 resource_context_.reset();
1149 }
1150
CreateMainHttpFactory(const ProfileParams * profile_params,net::HttpCache::BackendFactory * main_backend) const1151 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(¶ms);
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
CreateHttpFactory(net::HttpNetworkSession * shared_session,net::HttpCache::BackendFactory * backend) const1182 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
SetCookieSettingsForTesting(CookieSettings * cookie_settings)1191 void ProfileIOData::SetCookieSettingsForTesting(
1192 CookieSettings* cookie_settings) {
1193 DCHECK(!cookie_settings_.get());
1194 cookie_settings_ = cookie_settings;
1195 }
1196
set_signin_names_for_testing(SigninNamesOnIOThread * signin_names)1197 void ProfileIOData::set_signin_names_for_testing(
1198 SigninNamesOnIOThread* signin_names) {
1199 signin_names_.reset(signin_names);
1200 }
1201