src/chrome/browser/profiles/profile_impl.cc

   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_impl.h"
   6
   7 #include <vector>
   8
   9 #include "base/bind.h"
  10 #include "base/callback.h"
  11 #include "base/command_line.h"
  12 #include "base/compiler_specific.h"
  13 #include "base/debug/trace_event.h"
  14 #include "base/environment.h"
  15 #include "base/files/file_path.h"
  16 #include "base/files/file_util.h"
  17 #include "base/memory/scoped_ptr.h"
  18 #include "base/path_service.h"
  19 #include "base/prefs/json_pref_store.h"
  20 #include "base/prefs/scoped_user_pref_update.h"
  21 #include "base/strings/string_number_conversions.h"
  22 #include "base/strings/string_util.h"
  23 #include "base/strings/stringprintf.h"
  24 #include "base/strings/utf_string_conversions.h"
  25 #include "base/synchronization/waitable_event.h"
  26 #include "base/threading/sequenced_worker_pool.h"
  27 #include "base/version.h"
  28 #include "chrome/browser/autocomplete/autocomplete_classifier.h"
  29 #include "chrome/browser/autocomplete/shortcuts_backend.h"
  30 #include "chrome/browser/background/background_contents_service_factory.h"
  31 #include "chrome/browser/background/background_mode_manager.h"
  32 #include "chrome/browser/bookmarks/bookmark_model_factory.h"
  33 #include "chrome/browser/browser_process.h"
  34 #include "chrome/browser/chrome_notification_types.h"
  35 #include "chrome/browser/content_settings/cookie_settings.h"
  36 #include "chrome/browser/content_settings/host_content_settings_map.h"
  37 #include "chrome/browser/dom_distiller/profile_utils.h"
  38 #include "chrome/browser/domain_reliability/service_factory.h"
  39 #include "chrome/browser/download/chrome_download_manager_delegate.h"
  40 #include "chrome/browser/download/download_service.h"
  41 #include "chrome/browser/download/download_service_factory.h"
  42 #include "chrome/browser/history/top_sites.h"
  43 #include "chrome/browser/net/net_pref_observer.h"
  44 #include "chrome/browser/net/predictor.h"
  45 #include "chrome/browser/net/pref_proxy_config_tracker.h"
  46 #include "chrome/browser/net/proxy_service_factory.h"
  47 #include "chrome/browser/net/spdyproxy/data_reduction_proxy_chrome_configurator.h"
  48 #include "chrome/browser/net/spdyproxy/data_reduction_proxy_chrome_settings.h"
  49 #include "chrome/browser/net/spdyproxy/data_reduction_proxy_chrome_settings_factory.h"
  50 #include "chrome/browser/net/ssl_config_service_manager.h"
  51 #include "chrome/browser/plugins/chrome_plugin_service_filter.h"
  52 #include "chrome/browser/plugins/plugin_prefs.h"
  53 #include "chrome/browser/policy/profile_policy_connector.h"
  54 #include "chrome/browser/policy/profile_policy_connector_factory.h"
  55 #include "chrome/browser/prefs/browser_prefs.h"
  56 #include "chrome/browser/prefs/chrome_pref_service_factory.h"
  57 #include "chrome/browser/prefs/pref_service_syncable.h"
  58 #include "chrome/browser/prefs/tracked/tracked_preference_validation_delegate.h"
  59 #include "chrome/browser/prerender/prerender_manager_factory.h"
  60 #include "chrome/browser/profiles/bookmark_model_loaded_observer.h"
  61 #include "chrome/browser/profiles/chrome_version_service.h"
  62 #include "chrome/browser/profiles/gaia_info_update_service_factory.h"
  63 #include "chrome/browser/profiles/profile_destroyer.h"
  64 #include "chrome/browser/profiles/profile_info_cache.h"
  65 #include "chrome/browser/profiles/profile_manager.h"
  66 #include "chrome/browser/profiles/profile_metrics.h"
  67 #include "chrome/browser/safe_browsing/safe_browsing_service.h"
  68 #include "chrome/browser/services/gcm/gcm_profile_service.h"
  69 #include "chrome/browser/services/gcm/gcm_profile_service_factory.h"
  70 #include "chrome/browser/services/gcm/push_messaging_service_impl.h"
  71 #include "chrome/browser/sessions/session_service_factory.h"
  72 #include "chrome/browser/signin/signin_ui_util.h"
  73 #include "chrome/browser/ssl/chrome_ssl_host_state_delegate.h"
  74 #include "chrome/browser/ssl/chrome_ssl_host_state_delegate_factory.h"
  75 #include "chrome/browser/ui/startup/startup_browser_creator.h"
  76 #include "chrome/common/chrome_constants.h"
  77 #include "chrome/common/chrome_paths_internal.h"
  78 #include "chrome/common/chrome_switches.h"
  79 #include "chrome/common/chrome_version_info.h"
  80 #include "chrome/common/pref_names.h"
  81 #include "chrome/common/url_constants.h"
  82 #include "chrome/grit/chromium_strings.h"
  83 #include "components/bookmarks/browser/bookmark_model.h"
  84 #include "components/data_reduction_proxy/browser/data_reduction_proxy_params.h"
  85 #include "components/data_reduction_proxy/browser/data_reduction_proxy_settings.h"
  86 #include "components/data_reduction_proxy/browser/data_reduction_proxy_statistics_prefs.h"
  87 #include "components/domain_reliability/monitor.h"
  88 #include "components/domain_reliability/service.h"
  89 #include "components/keyed_service/content/browser_context_dependency_manager.h"
  90 #include "components/metrics/metrics_service.h"
  91 #include "components/pref_registry/pref_registry_syncable.h"
  92 #include "components/startup_metric_utils/startup_metric_utils.h"
  93 #include "components/url_fixer/url_fixer.h"
  94 #include "components/user_prefs/user_prefs.h"
  95 #include "content/public/browser/browser_thread.h"
  96 #include "content/public/browser/dom_storage_context.h"
  97 #include "content/public/browser/host_zoom_map.h"
  98 #include "content/public/browser/notification_service.h"
  99 #include "content/public/browser/render_process_host.h"
 100 #include "content/public/browser/storage_partition.h"
 101 #include "content/public/browser/url_data_source.h"
 102 #include "content/public/browser/user_metrics.h"
 103 #include "content/public/common/content_constants.h"
 104 #include "content/public/common/page_zoom.h"
 105 #include "ui/base/l10n/l10n_util.h"
 106
 107 #if defined(OS_ANDROID)
 108 #include "chrome/browser/media/protected_media_identifier_permission_context.h"
 109 #include "chrome/browser/media/protected_media_identifier_permission_context_factory.h"
 110 #endif
 111
 112 #if defined(OS_CHROMEOS)
 113 #include "chrome/browser/chromeos/locale_change_guard.h"
 114 #include "chrome/browser/chromeos/preferences.h"
 115 #include "chrome/browser/chromeos/profiles/profile_helper.h"
 116 #include "components/user_manager/user_manager.h"
 117 #endif
 118
 119 #if defined(ENABLE_CONFIGURATION_POLICY)
 120 #include "chrome/browser/policy/schema_registry_service.h"
 121 #include "chrome/browser/policy/schema_registry_service_factory.h"
 122 #include "components/policy/core/browser/browser_policy_connector.h"
 123 #if defined(OS_CHROMEOS)
 124 #include "chrome/browser/chromeos/login/login_utils.h"
 125 #include "chrome/browser/chromeos/policy/user_cloud_policy_manager_chromeos.h"
 126 #include "chrome/browser/chromeos/policy/user_cloud_policy_manager_factory_chromeos.h"
 127 #else
 128 #include "chrome/browser/policy/cloud/user_cloud_policy_manager_factory.h"
 129 #include "components/policy/core/common/cloud/user_cloud_policy_manager.h"
 130 #endif
 131 #endif
 132
 133 #if defined(ENABLE_EXTENSIONS)
 134 #include "chrome/browser/extensions/extension_service.h"
 135 #include "chrome/browser/extensions/extension_special_storage_policy.h"
 136 #include "chrome/browser/ui/webui/extensions/extension_icon_source.h"
 137 #include "extensions/browser/extension_pref_store.h"
 138 #include "extensions/browser/extension_pref_value_map.h"
 139 #include "extensions/browser/extension_pref_value_map_factory.h"
 140 #include "extensions/browser/extension_system.h"
 141 #include "extensions/browser/guest_view/guest_view_manager.h"
 142 #endif
 143
 144 #if defined(ENABLE_MANAGED_USERS)
 145 #include "chrome/browser/supervised_user/supervised_user_settings_service.h"
 146 #include "chrome/browser/supervised_user/supervised_user_settings_service_factory.h"
 147 #endif
 148
 149 using base::Time;
 150 using base::TimeDelta;
 151 using base::UserMetricsAction;
 152 using content::BrowserThread;
 153 using content::DownloadManagerDelegate;
 154 using content::HostZoomMap;
 155
 156 namespace {
 157
 158 #if defined(ENABLE_SESSION_SERVICE)
 159 // Delay, in milliseconds, before we explicitly create the SessionService.
 160 const int kCreateSessionServiceDelayMS = 500;
 161 #endif
 162
 163 // Text content of README file created in each profile directory. Both %s
 164 // placeholders must contain the product name. This is not localizable and hence
 165 // not in resources.
 166 const char kReadmeText[] =
 167     "%s settings and storage represent user-selected preferences and "
 168     "information and MUST not be extracted, overwritten or modified except "
 169     "through %s defined APIs.";
 170
 171 // Value written to prefs for EXIT_CRASHED and EXIT_SESSION_ENDED.
 172 const char kPrefExitTypeCrashed[] = "Crashed";
 173 const char kPrefExitTypeSessionEnded[] = "SessionEnded";
 174
 175 // Helper method needed because PostTask cannot currently take a Callback
 176 // function with non-void return type.
 177 void CreateDirectoryAndSignal(const base::FilePath& path,
 178                               base::WaitableEvent* done_creating) {
 179   DVLOG(1) << "Creating directory " << path.value();
 180   base::CreateDirectory(path);
 181   done_creating->Signal();
 182 }
 183
 184 // Task that blocks the FILE thread until CreateDirectoryAndSignal() finishes on
 185 // blocking I/O pool.
 186 void BlockFileThreadOnDirectoryCreate(base::WaitableEvent* done_creating) {
 187   done_creating->Wait();
 188 }
 189
 190 // Initiates creation of profile directory on |sequenced_task_runner| and
 191 // ensures that FILE thread is blocked until that operation finishes.
 192 void CreateProfileDirectory(base::SequencedTaskRunner* sequenced_task_runner,
 193                             const base::FilePath& path) {
 194   base::WaitableEvent* done_creating = new base::WaitableEvent(false, false);
 195   sequenced_task_runner->PostTask(FROM_HERE,
 196                                   base::Bind(&CreateDirectoryAndSignal,
 197                                              path,
 198                                              done_creating));
 199   // Block the FILE thread until directory is created on I/O pool to make sure
 200   // that we don't attempt any operation until that part completes.
 201   BrowserThread::PostTask(
 202       BrowserThread::FILE, FROM_HERE,
 203       base::Bind(&BlockFileThreadOnDirectoryCreate,
 204                  base::Owned(done_creating)));
 205 }
 206
 207 base::FilePath GetCachePath(const base::FilePath& base) {
 208   return base.Append(chrome::kCacheDirname);
 209 }
 210
 211 base::FilePath GetMediaCachePath(const base::FilePath& base) {
 212   return base.Append(chrome::kMediaCacheDirname);
 213 }
 214
 215 void EnsureReadmeFile(const base::FilePath& base) {
 216   base::FilePath readme_path = base.Append(chrome::kReadmeFilename);
 217   if (base::PathExists(readme_path))
 218     return;
 219   std::string product_name = l10n_util::GetStringUTF8(IDS_PRODUCT_NAME);
 220   std::string readme_text = base::StringPrintf(
 221       kReadmeText, product_name.c_str(), product_name.c_str());
 222   if (base::WriteFile(readme_path, readme_text.data(), readme_text.size()) ==
 223       -1) {
 224     LOG(ERROR) << "Could not create README file.";
 225   }
 226 }
 227
 228 // Converts the kSessionExitedCleanly pref to the corresponding EXIT_TYPE.
 229 Profile::ExitType SessionTypePrefValueToExitType(const std::string& value) {
 230   if (value == kPrefExitTypeSessionEnded)
 231     return Profile::EXIT_SESSION_ENDED;
 232   if (value == kPrefExitTypeCrashed)
 233     return Profile::EXIT_CRASHED;
 234   return Profile::EXIT_NORMAL;
 235 }
 236
 237 // Converts an ExitType into a string that is written to prefs.
 238 std::string ExitTypeToSessionTypePrefValue(Profile::ExitType type) {
 239   switch (type) {
 240     case Profile::EXIT_NORMAL:
 241         return ProfileImpl::kPrefExitTypeNormal;
 242     case Profile::EXIT_SESSION_ENDED:
 243       return kPrefExitTypeSessionEnded;
 244     case Profile::EXIT_CRASHED:
 245       return kPrefExitTypeCrashed;
 246   }
 247   NOTREACHED();
 248   return std::string();
 249 }
 250
 251 PrefStore* CreateExtensionPrefStore(Profile* profile,
 252                                     bool incognito_pref_store) {
 253 #if defined(ENABLE_EXTENSIONS)
 254   return new ExtensionPrefStore(
 255       ExtensionPrefValueMapFactory::GetForBrowserContext(profile),
 256       incognito_pref_store);
 257 #else
 258   return NULL;
 259 #endif
 260 }
 261
 262 }  // namespace
 263
 264 // static
 265 Profile* Profile::CreateProfile(const base::FilePath& path,
 266                                 Delegate* delegate,
 267                                 CreateMode create_mode) {
 268   TRACE_EVENT_BEGIN1("browser",
 269                      "Profile::CreateProfile",
 270                      "profile_path",
 271                      path.value().c_str());
 272
 273   // Get sequenced task runner for making sure that file operations of
 274   // this profile (defined by |path|) are executed in expected order
 275   // (what was previously assured by the FILE thread).
 276   scoped_refptr<base::SequencedTaskRunner> sequenced_task_runner =
 277       JsonPrefStore::GetTaskRunnerForFile(path,
 278                                           BrowserThread::GetBlockingPool());
 279   if (create_mode == CREATE_MODE_ASYNCHRONOUS) {
 280     DCHECK(delegate);
 281     CreateProfileDirectory(sequenced_task_runner.get(), path);
 282   } else if (create_mode == CREATE_MODE_SYNCHRONOUS) {
 283     if (!base::PathExists(path)) {
 284       // TODO(tc): http://b/1094718 Bad things happen if we can't write to the
 285       // profile directory.  We should eventually be able to run in this
 286       // situation.
 287       if (!base::CreateDirectory(path))
 288         return NULL;
 289     }
 290   } else {
 291     NOTREACHED();
 292   }
 293
 294   return new ProfileImpl(
 295       path, delegate, create_mode, sequenced_task_runner.get());
 296 }
 297
 298 // static
 299 int ProfileImpl::create_readme_delay_ms = 60000;
 300
 301 // static
 302 const char* const ProfileImpl::kPrefExitTypeNormal = "Normal";
 303
 304 // static
 305 void ProfileImpl::RegisterProfilePrefs(
 306     user_prefs::PrefRegistrySyncable* registry) {
 307   registry->RegisterBooleanPref(
 308       prefs::kSavingBrowserHistoryDisabled,
 309       false,
 310       user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF);
 311   registry->RegisterBooleanPref(
 312       prefs::kAllowDeletingBrowserHistory,
 313       true,
 314       user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF);
 315   registry->RegisterBooleanPref(
 316       prefs::kSigninAllowed,
 317       true,
 318       user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF);
 319   registry->RegisterBooleanPref(
 320       prefs::kForceSafeSearch,
 321       false,
 322       user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF);
 323   registry->RegisterIntegerPref(
 324       prefs::kProfileAvatarIndex,
 325       -1,
 326       user_prefs::PrefRegistrySyncable::SYNCABLE_PREF);
 327   // Whether a profile is using an avatar without having explicitely chosen it
 328   // (i.e. was assigned by default by legacy profile creation).
 329   registry->RegisterBooleanPref(
 330       prefs::kProfileUsingDefaultAvatar,
 331       true,
 332       user_prefs::PrefRegistrySyncable::SYNCABLE_PREF);
 333   registry->RegisterBooleanPref(
 334       prefs::kProfileUsingGAIAAvatar,
 335       false,
 336       user_prefs::PrefRegistrySyncable::SYNCABLE_PREF);
 337   // Whether a profile is using a default avatar name (eg. Pickles or Person 1).
 338   registry->RegisterBooleanPref(
 339       prefs::kProfileUsingDefaultName,
 340       true,
 341       user_prefs::PrefRegistrySyncable::SYNCABLE_PREF);
 342   registry->RegisterStringPref(
 343       prefs::kSupervisedUserId,
 344       std::string(),
 345       user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF);
 346   registry->RegisterStringPref(prefs::kProfileName,
 347                                std::string(),
 348                                user_prefs::PrefRegistrySyncable::SYNCABLE_PREF);
 349   registry->RegisterStringPref(prefs::kHomePage,
 350                                std::string(),
 351                                user_prefs::PrefRegistrySyncable::SYNCABLE_PREF);
 352 #if defined(ENABLE_PRINTING)
 353   registry->RegisterBooleanPref(
 354       prefs::kPrintingEnabled,
 355       true,
 356       user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF);
 357 #endif
 358   registry->RegisterBooleanPref(
 359       prefs::kPrintPreviewDisabled,
 360       false,
 361       user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF);
 362   registry->RegisterBooleanPref(
 363       prefs::kForceEphemeralProfiles,
 364       false,
 365       user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF);
 366
 367   // Initialize the cache prefs.
 368   registry->RegisterFilePathPref(
 369       prefs::kDiskCacheDir,
 370       base::FilePath(),
 371       user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF);
 372   registry->RegisterIntegerPref(
 373       prefs::kDiskCacheSize,
 374       0,
 375       user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF);
 376   registry->RegisterIntegerPref(
 377       prefs::kMediaCacheSize,
 378       0,
 379       user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF);
 380
 381   // Deprecated. Kept around for migration.
 382   registry->RegisterBooleanPref(
 383       prefs::kClearSiteDataOnExit,
 384       false,
 385       user_prefs::PrefRegistrySyncable::SYNCABLE_PREF);
 386 }
 387
 388 ProfileImpl::ProfileImpl(
 389     const base::FilePath& path,
 390     Delegate* delegate,
 391     CreateMode create_mode,
 392     base::SequencedTaskRunner* sequenced_task_runner)
 393     : path_(path),
 394       pref_registry_(new user_prefs::PrefRegistrySyncable),
 395       io_data_(this),
 396       host_content_settings_map_(NULL),
 397       last_session_exit_type_(EXIT_NORMAL),
 398       start_time_(Time::Now()),
 399       delegate_(delegate),
 400       predictor_(NULL) {
 401   TRACE_EVENT0("browser", "ProfileImpl::ctor")
 402   DCHECK(!path.empty()) << "Using an empty path will attempt to write " <<
 403                             "profile files to the root directory!";
 404
 405 #if defined(ENABLE_SESSION_SERVICE)
 406   create_session_service_timer_.Start(FROM_HERE,
 407       TimeDelta::FromMilliseconds(kCreateSessionServiceDelayMS), this,
 408       &ProfileImpl::EnsureSessionServiceCreated);
 409 #endif
 410
 411   // Determine if prefetch is enabled for this profile.
 412   // If not profile_manager is present, it means we are in a unittest.
 413   const CommandLine* command_line = CommandLine::ForCurrentProcess();
 414   predictor_ = chrome_browser_net::Predictor::CreatePredictor(
 415       !command_line->HasSwitch(switches::kDisablePreconnect),
 416       !command_line->HasSwitch(switches::kDnsPrefetchDisable),
 417       g_browser_process->profile_manager() == NULL);
 418
 419   // If we are creating the profile synchronously, then we should load the
 420   // policy data immediately.
 421   bool force_immediate_policy_load = (create_mode == CREATE_MODE_SYNCHRONOUS);
 422 #if defined(ENABLE_CONFIGURATION_POLICY)
 423   policy::BrowserPolicyConnector* connector =
 424       g_browser_process->browser_policy_connector();
 425   schema_registry_service_ =
 426       policy::SchemaRegistryServiceFactory::CreateForContext(
 427           this, connector->GetChromeSchema(), connector->GetSchemaRegistry());
 428 #if defined(OS_CHROMEOS)
 429   cloud_policy_manager_ =
 430       policy::UserCloudPolicyManagerFactoryChromeOS::CreateForProfile(
 431           this, force_immediate_policy_load, sequenced_task_runner);
 432 #else
 433   cloud_policy_manager_ =
 434       policy::UserCloudPolicyManagerFactory::CreateForOriginalBrowserContext(
 435           this,
 436           force_immediate_policy_load,
 437           sequenced_task_runner,
 438           BrowserThread::GetMessageLoopProxyForThread(BrowserThread::FILE),
 439           BrowserThread::GetMessageLoopProxyForThread(BrowserThread::IO));
 440 #endif
 441 #endif
 442   profile_policy_connector_ =
 443       policy::ProfilePolicyConnectorFactory::CreateForProfile(
 444           this, force_immediate_policy_load);
 445
 446   DCHECK(create_mode == CREATE_MODE_ASYNCHRONOUS ||
 447          create_mode == CREATE_MODE_SYNCHRONOUS);
 448   bool async_prefs = create_mode == CREATE_MODE_ASYNCHRONOUS;
 449
 450 #if defined(OS_CHROMEOS)
 451   if (chromeos::ProfileHelper::IsSigninProfile(this))
 452     chrome::RegisterLoginProfilePrefs(pref_registry_.get());
 453   else
 454 #endif
 455   chrome::RegisterUserProfilePrefs(pref_registry_.get());
 456
 457   BrowserContextDependencyManager::GetInstance()->
 458       RegisterProfilePrefsForServices(this, pref_registry_.get());
 459
 460   SupervisedUserSettingsService* supervised_user_settings = NULL;
 461 #if defined(ENABLE_MANAGED_USERS)
 462   supervised_user_settings =
 463       SupervisedUserSettingsServiceFactory::GetForProfile(this);
 464   supervised_user_settings->Init(
 465       path_, sequenced_task_runner, create_mode == CREATE_MODE_SYNCHRONOUS);
 466 #endif
 467
 468   scoped_refptr<SafeBrowsingService> safe_browsing_service(
 469       g_browser_process->safe_browsing_service());
 470   if (safe_browsing_service.get()) {
 471     pref_validation_delegate_ =
 472         safe_browsing_service->CreatePreferenceValidationDelegate(this).Pass();
 473   }
 474
 475   {
 476     // On startup, preference loading is always synchronous so a scoped timer
 477     // will work here.
 478     startup_metric_utils::ScopedSlowStartupUMA
 479         scoped_timer("Startup.SlowStartupPreferenceLoading");
 480     prefs_ = chrome_prefs::CreateProfilePrefs(
 481         path_,
 482         sequenced_task_runner,
 483         pref_validation_delegate_.get(),
 484         profile_policy_connector_->policy_service(),
 485         supervised_user_settings,
 486         CreateExtensionPrefStore(this, false),
 487         pref_registry_,
 488         async_prefs).Pass();
 489     // Register on BrowserContext.
 490     user_prefs::UserPrefs::Set(this, prefs_.get());
 491   }
 492
 493   startup_metric_utils::ScopedSlowStartupUMA
 494       scoped_timer("Startup.SlowStartupFinalProfileInit");
 495   if (async_prefs) {
 496     // Wait for the notification that prefs has been loaded
 497     // (successfully or not).  Note that we can use base::Unretained
 498     // because the PrefService is owned by this class and lives on
 499     // the same thread.
 500     prefs_->AddPrefInitObserver(base::Bind(&ProfileImpl::OnPrefsLoaded,
 501                                            base::Unretained(this)));
 502   } else {
 503     // Prefs were loaded synchronously so we can continue directly.
 504     OnPrefsLoaded(true);
 505   }
 506 }
 507
 508 void ProfileImpl::DoFinalInit() {
 509   TRACE_EVENT0("browser", "ProfileImpl::DoFinalInit")
 510   PrefService* prefs = GetPrefs();
 511   pref_change_registrar_.Init(prefs);
 512   pref_change_registrar_.Add(
 513       prefs::kGoogleServicesUsername,
 514       base::Bind(&ProfileImpl::UpdateProfileUserNameCache,
 515                  base::Unretained(this)));
 516   pref_change_registrar_.Add(
 517       prefs::kSupervisedUserId,
 518       base::Bind(&ProfileImpl::UpdateProfileSupervisedUserIdCache,
 519                  base::Unretained(this)));
 520   pref_change_registrar_.Add(
 521       prefs::kDefaultZoomLevel,
 522       base::Bind(&ProfileImpl::OnDefaultZoomLevelChanged,
 523                  base::Unretained(this)));
 524
 525   // Changes in the profile avatar.
 526   pref_change_registrar_.Add(
 527       prefs::kProfileAvatarIndex,
 528       base::Bind(&ProfileImpl::UpdateProfileAvatarCache,
 529                  base::Unretained(this)));
 530   pref_change_registrar_.Add(
 531       prefs::kProfileUsingDefaultAvatar,
 532       base::Bind(&ProfileImpl::UpdateProfileAvatarCache,
 533                  base::Unretained(this)));
 534   pref_change_registrar_.Add(
 535       prefs::kProfileUsingGAIAAvatar,
 536       base::Bind(&ProfileImpl::UpdateProfileAvatarCache,
 537                  base::Unretained(this)));
 538
 539   // Changes in the profile name.
 540   pref_change_registrar_.Add(
 541       prefs::kProfileUsingDefaultName,
 542       base::Bind(&ProfileImpl::UpdateProfileNameCache,
 543                  base::Unretained(this)));
 544   pref_change_registrar_.Add(
 545       prefs::kProfileName,
 546       base::Bind(&ProfileImpl::UpdateProfileNameCache,
 547                  base::Unretained(this)));
 548
 549   pref_change_registrar_.Add(
 550       prefs::kForceEphemeralProfiles,
 551       base::Bind(&ProfileImpl::UpdateProfileIsEphemeralCache,
 552                  base::Unretained(this)));
 553
 554   // It would be nice to use PathService for fetching this directory, but
 555   // the cache directory depends on the profile directory, which isn't available
 556   // to PathService.
 557   chrome::GetUserCacheDirectory(path_, &base_cache_path_);
 558   // Always create the cache directory asynchronously.
 559   scoped_refptr<base::SequencedTaskRunner> sequenced_task_runner =
 560       JsonPrefStore::GetTaskRunnerForFile(base_cache_path_,
 561                                           BrowserThread::GetBlockingPool());
 562   CreateProfileDirectory(sequenced_task_runner.get(), base_cache_path_);
 563
 564   // Now that the profile is hooked up to receive pref change notifications to
 565   // kGoogleServicesUsername, initialize components that depend on it to reflect
 566   // the current value.
 567   UpdateProfileUserNameCache();
 568   UpdateProfileSupervisedUserIdCache();
 569   UpdateProfileIsEphemeralCache();
 570   GAIAInfoUpdateServiceFactory::GetForProfile(this);
 571
 572   PrefService* local_state = g_browser_process->local_state();
 573   ssl_config_service_manager_.reset(
 574       SSLConfigServiceManager::CreateDefaultManager(local_state));
 575
 576   // Initialize the BackgroundModeManager - this has to be done here before
 577   // InitExtensions() is called because it relies on receiving notifications
 578   // when extensions are loaded. BackgroundModeManager is not needed under
 579   // ChromeOS because Chrome is always running, no need for special keep-alive
 580   // or launch-on-startup support unless kKeepAliveForTest is set.
 581   bool init_background_mode_manager = true;
 582 #if defined(OS_CHROMEOS)
 583   if (!CommandLine::ForCurrentProcess()->HasSwitch(switches::kKeepAliveForTest))
 584     init_background_mode_manager = false;
 585 #endif
 586   if (init_background_mode_manager) {
 587     if (g_browser_process->background_mode_manager())
 588       g_browser_process->background_mode_manager()->RegisterProfile(this);
 589   }
 590
 591   base::FilePath cookie_path = GetPath();
 592   cookie_path = cookie_path.Append(chrome::kCookieFilename);
 593   base::FilePath channel_id_path = GetPath();
 594   channel_id_path = channel_id_path.Append(chrome::kChannelIDFilename);
 595   base::FilePath cache_path = base_cache_path_;
 596   int cache_max_size;
 597   GetCacheParameters(false, &cache_path, &cache_max_size);
 598   cache_path = GetCachePath(cache_path);
 599
 600   base::FilePath media_cache_path = base_cache_path_;
 601   int media_cache_max_size;
 602   GetCacheParameters(true, &media_cache_path, &media_cache_max_size);
 603   media_cache_path = GetMediaCachePath(media_cache_path);
 604
 605   base::FilePath extensions_cookie_path = GetPath();
 606   extensions_cookie_path =
 607       extensions_cookie_path.Append(chrome::kExtensionsCookieFilename);
 608
 609   base::FilePath infinite_cache_path = GetPath();
 610   infinite_cache_path =
 611       infinite_cache_path.Append(FILE_PATH_LITERAL("Infinite Cache"));
 612
 613 #if defined(OS_ANDROID)
 614   SessionStartupPref::Type startup_pref_type =
 615       SessionStartupPref::GetDefaultStartupType();
 616 #else
 617   SessionStartupPref::Type startup_pref_type =
 618       StartupBrowserCreator::GetSessionStartupPref(
 619           *CommandLine::ForCurrentProcess(), this).type;
 620 #endif
 621   content::CookieStoreConfig::SessionCookieMode session_cookie_mode =
 622       content::CookieStoreConfig::PERSISTANT_SESSION_COOKIES;
 623   if (GetLastSessionExitType() == Profile::EXIT_CRASHED ||
 624       startup_pref_type == SessionStartupPref::LAST) {
 625     session_cookie_mode = content::CookieStoreConfig::RESTORED_SESSION_COOKIES;
 626   }
 627
 628   InitHostZoomMap();
 629
 630   base::Callback<void(bool)> data_reduction_proxy_unavailable;
 631   scoped_ptr<data_reduction_proxy::DataReductionProxyParams>
 632       data_reduction_proxy_params;
 633   scoped_ptr<DataReductionProxyChromeConfigurator> chrome_configurator;
 634   scoped_ptr<data_reduction_proxy::DataReductionProxyStatisticsPrefs>
 635       data_reduction_proxy_statistics_prefs;
 636   DataReductionProxyChromeSettings* data_reduction_proxy_chrome_settings =
 637       DataReductionProxyChromeSettingsFactory::GetForBrowserContext(this);
 638   data_reduction_proxy_params =
 639       data_reduction_proxy_chrome_settings->params()->Clone();
 640   data_reduction_proxy_unavailable =
 641       base::Bind(
 642           &data_reduction_proxy::DataReductionProxySettings::SetUnreachable,
 643           base::Unretained(data_reduction_proxy_chrome_settings));
 644   // The configurator is used by DataReductionProxyChromeSettings and
 645   // ProfileIOData. Ownership is passed to the latter via ProfileIOData::Handle,
 646   // which is only destroyed after BrowserContextKeyedServices,
 647   // including DataReductionProxyChromeSettings.
 648   chrome_configurator.reset(
 649       new DataReductionProxyChromeConfigurator(
 650           prefs_.get(),
 651           BrowserThread::GetMessageLoopProxyForThread(BrowserThread::IO)));
 652   // Retain a raw pointer to use for initialization of data reduction proxy
 653   // settings after ownership is passed.
 654   DataReductionProxyChromeConfigurator*
 655       data_reduction_proxy_chrome_configurator = chrome_configurator.get();
 656 #if defined(OS_ANDROID) || defined(OS_IOS)
 657   // On mobile we write data reduction proxy prefs directly to the pref service.
 658   // On desktop we store data reduction proxy prefs in memory, writing to disk
 659   // every 60 minutes and on termination. Shutdown hooks must be added for
 660   // Android and iOS in order for non-zero delays to be supported.
 661   // (http://crbug.com/408264)
 662   base::TimeDelta commit_delay = base::TimeDelta();
 663 #else
 664   base::TimeDelta commit_delay = base::TimeDelta::FromMinutes(60);
 665 #endif
 666   data_reduction_proxy_statistics_prefs =
 667       scoped_ptr<data_reduction_proxy::DataReductionProxyStatisticsPrefs>(
 668           new data_reduction_proxy::DataReductionProxyStatisticsPrefs(
 669               g_browser_process->local_state(),
 670               base::MessageLoopProxy::current(),
 671               commit_delay));
 672   data_reduction_proxy_chrome_settings->SetDataReductionProxyStatisticsPrefs(
 673       data_reduction_proxy_statistics_prefs.get());
 674
 675   // Make sure we initialize the ProfileIOData after everything else has been
 676   // initialized that we might be reading from the IO thread.
 677
 678   io_data_.Init(cookie_path, channel_id_path, cache_path,
 679                 cache_max_size, media_cache_path, media_cache_max_size,
 680                 extensions_cookie_path, GetPath(), infinite_cache_path,
 681                 predictor_, session_cookie_mode, GetSpecialStoragePolicy(),
 682                 CreateDomainReliabilityMonitor(local_state),
 683                 data_reduction_proxy_unavailable,
 684                 chrome_configurator.Pass(),
 685                 data_reduction_proxy_params.Pass(),
 686                 data_reduction_proxy_statistics_prefs.Pass());
 687   data_reduction_proxy_chrome_settings->InitDataReductionProxySettings(
 688       data_reduction_proxy_chrome_configurator,
 689       prefs_.get(),
 690       g_browser_process->local_state(),
 691       GetRequestContext());
 692
 693 #if defined(ENABLE_PLUGINS)
 694   ChromePluginServiceFilter::GetInstance()->RegisterResourceContext(
 695       PluginPrefs::GetForProfile(this).get(),
 696       io_data_.GetResourceContextNoInit());
 697 #endif
 698
 699   // Delay README creation to not impact startup performance.
 700   BrowserThread::PostDelayedTask(
 701         BrowserThread::FILE, FROM_HERE,
 702         base::Bind(&EnsureReadmeFile, GetPath()),
 703         base::TimeDelta::FromMilliseconds(create_readme_delay_ms));
 704
 705   TRACE_EVENT0("browser", "ProfileImpl::SetSaveSessionStorageOnDisk");
 706   content::BrowserContext::GetDefaultStoragePartition(this)->
 707       GetDOMStorageContext()->SetSaveSessionStorageOnDisk();
 708
 709   // The DomDistillerViewerSource is not a normal WebUI so it must be registered
 710   // as a URLDataSource early.
 711   RegisterDomDistillerViewerSource(this);
 712
 713   // Creation has been finished.
 714   TRACE_EVENT_END1("browser",
 715                    "Profile::CreateProfile",
 716                    "profile_path",
 717                    path_.value().c_str());
 718
 719 #if defined(OS_CHROMEOS)
 720   if (chromeos::LoginUtils::Get()->RestartToApplyPerSessionFlagsIfNeed(this,
 721                                                                        true)) {
 722     return;
 723   }
 724 #endif
 725
 726   if (delegate_) {
 727     TRACE_EVENT0("browser", "ProfileImpl::DoFileInit:DelegateOnProfileCreated")
 728     delegate_->OnProfileCreated(this, true, IsNewProfile());
 729   }
 730
 731   content::NotificationService::current()->Notify(
 732       chrome::NOTIFICATION_PROFILE_CREATED,
 733       content::Source<Profile>(this),
 734       content::NotificationService::NoDetails());
 735
 736 #if !defined(OS_CHROMEOS)
 737   // Listen for bookmark model load, to bootstrap the sync service.
 738   // On CrOS sync service will be initialized after sign in.
 739   BookmarkModel* model = BookmarkModelFactory::GetForProfile(this);
 740   model->AddObserver(new BookmarkModelLoadedObserver(this));
 741 #endif
 742
 743   gcm::PushMessagingServiceImpl::InitializeForProfile(this);
 744
 745 #if !defined(OS_ANDROID) && !defined(OS_CHROMEOS) && !defined(OS_IOS)
 746   signin_ui_util::InitializePrefsForProfile(this);
 747 #endif
 748 }
 749
 750 void ProfileImpl::InitHostZoomMap() {
 751   HostZoomMap* host_zoom_map = HostZoomMap::GetDefaultForBrowserContext(this);
 752   host_zoom_map->SetDefaultZoomLevel(
 753       prefs_->GetDouble(prefs::kDefaultZoomLevel));
 754
 755   const base::DictionaryValue* host_zoom_dictionary =
 756       prefs_->GetDictionary(prefs::kPerHostZoomLevels);
 757   // Careful: The returned value could be NULL if the pref has never been set.
 758   if (host_zoom_dictionary != NULL) {
 759     std::vector<std::string> keys_to_remove;
 760     for (base::DictionaryValue::Iterator i(*host_zoom_dictionary); !i.IsAtEnd();
 761          i.Advance()) {
 762       const std::string& host(i.key());
 763       double zoom_level = 0;
 764
 765       bool success = i.value().GetAsDouble(&zoom_level);
 766       DCHECK(success);
 767
 768       // Filter out A) the empty host, B) zoom levels equal to the default; and
 769       // remember them, so that we can later erase them from Prefs.
 770       // Values of type A and B could have been stored due to crbug.com/364399.
 771       // Values of type B could further have been stored before the default zoom
 772       // level was set to its current value. In either case, SetZoomLevelForHost
 773       // will ignore type B values, thus, to have consistency with HostZoomMap's
 774       // internal state, these values must also be removed from Prefs.
 775       if (host.empty() ||
 776           content::ZoomValuesEqual(zoom_level,
 777                                    host_zoom_map->GetDefaultZoomLevel())) {
 778         keys_to_remove.push_back(host);
 779         continue;
 780       }
 781
 782       host_zoom_map->SetZoomLevelForHost(host, zoom_level);
 783     }
 784
 785     DictionaryPrefUpdate update(prefs_.get(), prefs::kPerHostZoomLevels);
 786     base::DictionaryValue* host_zoom_dictionary = update.Get();
 787     for (std::vector<std::string>::const_iterator it = keys_to_remove.begin();
 788          it != keys_to_remove.end(); ++it) {
 789       host_zoom_dictionary->RemoveWithoutPathExpansion(*it, NULL);
 790     }
 791   }
 792
 793   zoom_subscription_ = host_zoom_map->AddZoomLevelChangedCallback(
 794       base::Bind(&ProfileImpl::OnZoomLevelChanged, base::Unretained(this)));
 795 }
 796
 797 base::FilePath ProfileImpl::last_selected_directory() {
 798   return GetPrefs()->GetFilePath(prefs::kSelectFileLastDirectory);
 799 }
 800
 801 void ProfileImpl::set_last_selected_directory(const base::FilePath& path) {
 802   GetPrefs()->SetFilePath(prefs::kSelectFileLastDirectory, path);
 803 }
 804
 805 ProfileImpl::~ProfileImpl() {
 806   MaybeSendDestroyedNotification();
 807
 808   bool prefs_loaded = prefs_->GetInitializationStatus() !=
 809       PrefService::INITIALIZATION_STATUS_WAITING;
 810
 811 #if defined(ENABLE_SESSION_SERVICE)
 812   StopCreateSessionServiceTimer();
 813 #endif
 814
 815   // Remove pref observers
 816   pref_change_registrar_.RemoveAll();
 817
 818 #if defined(ENABLE_PLUGINS)
 819   ChromePluginServiceFilter::GetInstance()->UnregisterResourceContext(
 820       io_data_.GetResourceContextNoInit());
 821 #endif
 822
 823   // Destroy OTR profile and its profile services first.
 824   if (off_the_record_profile_) {
 825     ProfileDestroyer::DestroyOffTheRecordProfileNow(
 826         off_the_record_profile_.get());
 827   } else {
 828 #if defined(ENABLE_EXTENSIONS)
 829     ExtensionPrefValueMapFactory::GetForBrowserContext(this)->
 830         ClearAllIncognitoSessionOnlyPreferences();
 831 #endif
 832   }
 833
 834   BrowserContextDependencyManager::GetInstance()->DestroyBrowserContextServices(
 835       this);
 836
 837   if (top_sites_.get())
 838     top_sites_->Shutdown();
 839
 840   if (pref_proxy_config_tracker_)
 841     pref_proxy_config_tracker_->DetachFromPrefService();
 842
 843   if (host_content_settings_map_.get())
 844     host_content_settings_map_->ShutdownOnUIThread();
 845
 846   // This causes the Preferences file to be written to disk.
 847   if (prefs_loaded)
 848     SetExitType(EXIT_NORMAL);
 849 }
 850
 851 std::string ProfileImpl::GetProfileName() {
 852   return GetPrefs()->GetString(prefs::kGoogleServicesUsername);
 853 }
 854
 855 Profile::ProfileType ProfileImpl::GetProfileType() const {
 856   return REGULAR_PROFILE;
 857 }
 858
 859 base::FilePath ProfileImpl::GetPath() const {
 860   return path_;
 861 }
 862
 863 scoped_refptr<base::SequencedTaskRunner> ProfileImpl::GetIOTaskRunner() {
 864   return JsonPrefStore::GetTaskRunnerForFile(
 865       GetPath(), BrowserThread::GetBlockingPool());
 866 }
 867
 868 bool ProfileImpl::IsOffTheRecord() const {
 869   return false;
 870 }
 871
 872 Profile* ProfileImpl::GetOffTheRecordProfile() {
 873   if (!off_the_record_profile_) {
 874     scoped_ptr<Profile> p(CreateOffTheRecordProfile());
 875     off_the_record_profile_.swap(p);
 876
 877     content::NotificationService::current()->Notify(
 878         chrome::NOTIFICATION_PROFILE_CREATED,
 879         content::Source<Profile>(off_the_record_profile_.get()),
 880         content::NotificationService::NoDetails());
 881   }
 882   return off_the_record_profile_.get();
 883 }
 884
 885 void ProfileImpl::DestroyOffTheRecordProfile() {
 886   off_the_record_profile_.reset();
 887 #if defined(ENABLE_EXTENSIONS)
 888   ExtensionPrefValueMapFactory::GetForBrowserContext(this)->
 889       ClearAllIncognitoSessionOnlyPreferences();
 890 #endif
 891 }
 892
 893 bool ProfileImpl::HasOffTheRecordProfile() {
 894   return off_the_record_profile_.get() != NULL;
 895 }
 896
 897 Profile* ProfileImpl::GetOriginalProfile() {
 898   return this;
 899 }
 900
 901 bool ProfileImpl::IsSupervised() {
 902   return !GetPrefs()->GetString(prefs::kSupervisedUserId).empty();
 903 }
 904
 905 ExtensionSpecialStoragePolicy*
 906     ProfileImpl::GetExtensionSpecialStoragePolicy() {
 907 #if defined(ENABLE_EXTENSIONS)
 908   if (!extension_special_storage_policy_.get()) {
 909     TRACE_EVENT0("browser", "ProfileImpl::GetExtensionSpecialStoragePolicy")
 910     extension_special_storage_policy_ = new ExtensionSpecialStoragePolicy(
 911         CookieSettings::Factory::GetForProfile(this).get());
 912   }
 913   return extension_special_storage_policy_.get();
 914 #else
 915   return NULL;
 916 #endif
 917 }
 918
 919 void ProfileImpl::OnPrefsLoaded(bool success) {
 920   TRACE_EVENT0("browser", "ProfileImpl::OnPrefsLoaded")
 921   if (!success) {
 922     if (delegate_)
 923       delegate_->OnProfileCreated(this, false, false);
 924     return;
 925   }
 926
 927   // TODO(mirandac): remove migration code after 6 months (crbug.com/69995).
 928   if (g_browser_process->local_state())
 929     chrome::MigrateBrowserPrefs(this, g_browser_process->local_state());
 930   // TODO(ivankr): remove cleanup code eventually (crbug.com/165672).
 931   chrome::MigrateUserPrefs(this);
 932
 933   // |kSessionExitType| was added after |kSessionExitedCleanly|. If the pref
 934   // value is empty fallback to checking for |kSessionExitedCleanly|.
 935   const std::string exit_type_pref_value(
 936       prefs_->GetString(prefs::kSessionExitType));
 937   if (exit_type_pref_value.empty()) {
 938     last_session_exit_type_ =
 939         prefs_->GetBoolean(prefs::kSessionExitedCleanly) ?
 940           EXIT_NORMAL : EXIT_CRASHED;
 941   } else {
 942     last_session_exit_type_ =
 943         SessionTypePrefValueToExitType(exit_type_pref_value);
 944   }
 945   // Mark the session as open.
 946   prefs_->SetString(prefs::kSessionExitType, kPrefExitTypeCrashed);
 947   // Force this to true in case we fallback and use it.
 948   // TODO(sky): remove this in a couple of releases (m28ish).
 949   prefs_->SetBoolean(prefs::kSessionExitedCleanly, true);
 950
 951 #if defined(OS_ANDROID) && defined(FULL_SAFE_BROWSING)
 952   // Clear safe browsing setting in the case we need to roll back
 953   // for users enrolled in Finch trial before.
 954   if (!SafeBrowsingService::IsEnabledByFieldTrial())
 955     prefs_->ClearPref(prefs::kSafeBrowsingEnabled);
 956 #endif
 957
 958   g_browser_process->profile_manager()->InitProfileUserPrefs(this);
 959
 960   BrowserContextDependencyManager::GetInstance()->CreateBrowserContextServices(
 961       this);
 962
 963   DCHECK(!net_pref_observer_);
 964   {
 965     TRACE_EVENT0("browser", "ProfileImpl::OnPrefsLoaded:NetPrefObserver")
 966     net_pref_observer_.reset(new NetPrefObserver(prefs_.get()));
 967   }
 968
 969   chrome_prefs::SchedulePrefsFilePathVerification(path_);
 970
 971   ChromeVersionService::OnProfileLoaded(prefs_.get(), IsNewProfile());
 972   DoFinalInit();
 973 }
 974
 975 bool ProfileImpl::WasCreatedByVersionOrLater(const std::string& version) {
 976   Version profile_version(ChromeVersionService::GetVersion(prefs_.get()));
 977   Version arg_version(version);
 978   return (profile_version.CompareTo(arg_version) >= 0);
 979 }
 980
 981 void ProfileImpl::SetExitType(ExitType exit_type) {
 982 #if defined(OS_CHROMEOS)
 983   if (chromeos::ProfileHelper::IsSigninProfile(this))
 984     return;
 985 #endif
 986   if (!prefs_)
 987     return;
 988   ExitType current_exit_type = SessionTypePrefValueToExitType(
 989       prefs_->GetString(prefs::kSessionExitType));
 990   // This may be invoked multiple times during shutdown. Only persist the value
 991   // first passed in (unless it's a reset to the crash state, which happens when
 992   // foregrounding the app on mobile).
 993   if (exit_type == EXIT_CRASHED || current_exit_type == EXIT_CRASHED) {
 994     prefs_->SetString(prefs::kSessionExitType,
 995                       ExitTypeToSessionTypePrefValue(exit_type));
 996
 997     // NOTE: If you change what thread this writes on, be sure and update
 998     // chrome::SessionEnding().
 999     prefs_->CommitPendingWrite();
1000   }
1001 }
1002
1003 Profile::ExitType ProfileImpl::GetLastSessionExitType() {
1004   // last_session_exited_cleanly_ is set when the preferences are loaded. Force
1005   // it to be set by asking for the prefs.
1006   GetPrefs();
1007   return last_session_exit_type_;
1008 }
1009
1010 PrefService* ProfileImpl::GetPrefs() {
1011   DCHECK(prefs_);  // Should explicitly be initialized.
1012   return prefs_.get();
1013 }
1014
1015 PrefService* ProfileImpl::GetOffTheRecordPrefs() {
1016   DCHECK(prefs_);
1017   if (!otr_prefs_) {
1018     // The new ExtensionPrefStore is ref_counted and the new PrefService
1019     // stores a reference so that we do not leak memory here.
1020     otr_prefs_.reset(prefs_->CreateIncognitoPrefService(
1021         CreateExtensionPrefStore(this, true)));
1022   }
1023   return otr_prefs_.get();
1024 }
1025
1026 net::URLRequestContextGetter* ProfileImpl::CreateRequestContext(
1027     content::ProtocolHandlerMap* protocol_handlers,
1028     content::URLRequestInterceptorScopedVector request_interceptors) {
1029   return io_data_.CreateMainRequestContextGetter(
1030       protocol_handlers,
1031       request_interceptors.Pass(),
1032       g_browser_process->local_state(),
1033       g_browser_process->io_thread()).get();
1034 }
1035
1036 net::URLRequestContextGetter* ProfileImpl::GetRequestContext() {
1037   return GetDefaultStoragePartition(this)->GetURLRequestContext();
1038 }
1039
1040 net::URLRequestContextGetter* ProfileImpl::GetRequestContextForRenderProcess(
1041     int renderer_child_id) {
1042   content::RenderProcessHost* rph = content::RenderProcessHost::FromID(
1043       renderer_child_id);
1044
1045   return rph->GetStoragePartition()->GetURLRequestContext();
1046 }
1047
1048 net::URLRequestContextGetter* ProfileImpl::GetMediaRequestContext() {
1049   // Return the default media context.
1050   return io_data_.GetMediaRequestContextGetter().get();
1051 }
1052
1053 net::URLRequestContextGetter*
1054 ProfileImpl::GetMediaRequestContextForRenderProcess(
1055     int renderer_child_id) {
1056   content::RenderProcessHost* rph = content::RenderProcessHost::FromID(
1057       renderer_child_id);
1058   content::StoragePartition* storage_partition = rph->GetStoragePartition();
1059
1060   return storage_partition->GetMediaURLRequestContext();
1061 }
1062
1063 net::URLRequestContextGetter*
1064 ProfileImpl::GetMediaRequestContextForStoragePartition(
1065     const base::FilePath& partition_path,
1066     bool in_memory) {
1067   return io_data_
1068       .GetIsolatedMediaRequestContextGetter(partition_path, in_memory).get();
1069 }
1070
1071 content::ResourceContext* ProfileImpl::GetResourceContext() {
1072   return io_data_.GetResourceContext();
1073 }
1074
1075 net::URLRequestContextGetter* ProfileImpl::GetRequestContextForExtensions() {
1076   return io_data_.GetExtensionsRequestContextGetter().get();
1077 }
1078
1079 net::URLRequestContextGetter*
1080 ProfileImpl::CreateRequestContextForStoragePartition(
1081     const base::FilePath& partition_path,
1082     bool in_memory,
1083     content::ProtocolHandlerMap* protocol_handlers,
1084     content::URLRequestInterceptorScopedVector request_interceptors) {
1085   return io_data_.CreateIsolatedAppRequestContextGetter(
1086       partition_path,
1087       in_memory,
1088       protocol_handlers,
1089       request_interceptors.Pass()).get();
1090 }
1091
1092 net::SSLConfigService* ProfileImpl::GetSSLConfigService() {
1093   // If ssl_config_service_manager_ is null, this typically means that some
1094   // KeyedService is trying to create a RequestContext at startup,
1095   // but SSLConfigServiceManager is not initialized until DoFinalInit() which is
1096   // invoked after all KeyedServices have been initialized (see
1097   // http://crbug.com/171406).
1098   DCHECK(ssl_config_service_manager_) <<
1099       "SSLConfigServiceManager is not initialized yet";
1100   return ssl_config_service_manager_->Get();
1101 }
1102
1103 HostContentSettingsMap* ProfileImpl::GetHostContentSettingsMap() {
1104   if (!host_content_settings_map_.get()) {
1105     host_content_settings_map_ = new HostContentSettingsMap(GetPrefs(), false);
1106   }
1107   return host_content_settings_map_.get();
1108 }
1109
1110 content::BrowserPluginGuestManager* ProfileImpl::GetGuestManager() {
1111 #if defined(ENABLE_EXTENSIONS)
1112   return extensions::GuestViewManager::FromBrowserContext(this);
1113 #else
1114   return NULL;
1115 #endif
1116 }
1117
1118 DownloadManagerDelegate* ProfileImpl::GetDownloadManagerDelegate() {
1119   return DownloadServiceFactory::GetForBrowserContext(this)->
1120       GetDownloadManagerDelegate();
1121 }
1122
1123 storage::SpecialStoragePolicy* ProfileImpl::GetSpecialStoragePolicy() {
1124 #if defined(ENABLE_EXTENSIONS)
1125   return GetExtensionSpecialStoragePolicy();
1126 #else
1127   return NULL;
1128 #endif
1129 }
1130
1131 content::PushMessagingService* ProfileImpl::GetPushMessagingService() {
1132   return gcm::GCMProfileServiceFactory::GetForProfile(
1133       this)->push_messaging_service();
1134 }
1135
1136 content::SSLHostStateDelegate* ProfileImpl::GetSSLHostStateDelegate() {
1137   return ChromeSSLHostStateDelegateFactory::GetForProfile(this);
1138 }
1139
1140 bool ProfileImpl::IsSameProfile(Profile* profile) {
1141   if (profile == static_cast<Profile*>(this))
1142     return true;
1143   Profile* otr_profile = off_the_record_profile_.get();
1144   return otr_profile && profile == otr_profile;
1145 }
1146
1147 Time ProfileImpl::GetStartTime() const {
1148   return start_time_;
1149 }
1150
1151 history::TopSites* ProfileImpl::GetTopSites() {
1152   if (!top_sites_.get()) {
1153     top_sites_ = history::TopSites::Create(
1154         this, GetPath().Append(chrome::kTopSitesFilename));
1155   }
1156   return top_sites_.get();
1157 }
1158
1159 history::TopSites* ProfileImpl::GetTopSitesWithoutCreating() {
1160   return top_sites_.get();
1161 }
1162
1163 void ProfileImpl::OnDefaultZoomLevelChanged() {
1164   HostZoomMap::GetDefaultForBrowserContext(this)->SetDefaultZoomLevel(
1165       pref_change_registrar_.prefs()->GetDouble(prefs::kDefaultZoomLevel));
1166 }
1167
1168 void ProfileImpl::OnZoomLevelChanged(
1169     const HostZoomMap::ZoomLevelChange& change) {
1170
1171   if (change.mode != HostZoomMap::ZOOM_CHANGED_FOR_HOST)
1172     return;
1173   HostZoomMap* host_zoom_map = HostZoomMap::GetDefaultForBrowserContext(this);
1174   double level = change.zoom_level;
1175   DictionaryPrefUpdate update(prefs_.get(), prefs::kPerHostZoomLevels);
1176   base::DictionaryValue* host_zoom_dictionary = update.Get();
1177   if (content::ZoomValuesEqual(level, host_zoom_map->GetDefaultZoomLevel()))
1178     host_zoom_dictionary->RemoveWithoutPathExpansion(change.host, NULL);
1179   else
1180     host_zoom_dictionary->SetDoubleWithoutPathExpansion(change.host, level);
1181 }
1182
1183 #if defined(ENABLE_SESSION_SERVICE)
1184 void ProfileImpl::StopCreateSessionServiceTimer() {
1185   create_session_service_timer_.Stop();
1186 }
1187
1188 void ProfileImpl::EnsureSessionServiceCreated() {
1189   SessionServiceFactory::GetForProfile(this);
1190 }
1191 #endif
1192
1193 #if defined(OS_CHROMEOS)
1194 void ProfileImpl::ChangeAppLocale(
1195     const std::string& new_locale, AppLocaleChangedVia via) {
1196   if (new_locale.empty()) {
1197     NOTREACHED();
1198     return;
1199   }
1200   PrefService* local_state = g_browser_process->local_state();
1201   DCHECK(local_state);
1202   if (local_state->IsManagedPreference(prefs::kApplicationLocale))
1203     return;
1204   std::string pref_locale = GetPrefs()->GetString(prefs::kApplicationLocale);
1205   bool do_update_pref = true;
1206   switch (via) {
1207     case APP_LOCALE_CHANGED_VIA_SETTINGS:
1208     case APP_LOCALE_CHANGED_VIA_REVERT: {
1209       // We keep kApplicationLocaleBackup value as a reference.  In case value
1210       // of kApplicationLocale preference would change due to sync from other
1211       // device then kApplicationLocaleBackup value will trigger and allow us to
1212       // show notification about automatic locale change in LocaleChangeGuard.
1213       GetPrefs()->SetString(prefs::kApplicationLocaleBackup, new_locale);
1214       GetPrefs()->ClearPref(prefs::kApplicationLocaleAccepted);
1215       // We maintain kApplicationLocale property in both a global storage
1216       // and user's profile.  Global property determines locale of login screen,
1217       // while user's profile determines his personal locale preference.
1218       break;
1219     }
1220     case APP_LOCALE_CHANGED_VIA_LOGIN:
1221     case APP_LOCALE_CHANGED_VIA_PUBLIC_SESSION_LOGIN: {
1222       if (!pref_locale.empty()) {
1223         DCHECK(pref_locale == new_locale);
1224         std::string accepted_locale =
1225             GetPrefs()->GetString(prefs::kApplicationLocaleAccepted);
1226         if (accepted_locale == new_locale) {
1227           // If locale is accepted then we do not want to show LocaleChange
1228           // notification.  This notification is triggered by different values
1229           // of kApplicationLocaleBackup and kApplicationLocale preferences,
1230           // so make them identical.
1231           GetPrefs()->SetString(prefs::kApplicationLocaleBackup, new_locale);
1232         } else {
1233           // Back up locale of login screen.
1234           std::string cur_locale = g_browser_process->GetApplicationLocale();
1235           GetPrefs()->SetString(prefs::kApplicationLocaleBackup, cur_locale);
1236           if (locale_change_guard_ == NULL)
1237             locale_change_guard_.reset(new chromeos::LocaleChangeGuard(this));
1238           locale_change_guard_->PrepareChangingLocale(cur_locale, new_locale);
1239         }
1240       } else {
1241         std::string cur_locale = g_browser_process->GetApplicationLocale();
1242         std::string backup_locale =
1243             GetPrefs()->GetString(prefs::kApplicationLocaleBackup);
1244         // Profile synchronization takes time and is not completed at that
1245         // moment at first login.  So we initialize locale preference in steps:
1246         // (1) first save it to temporary backup;
1247         // (2) on next login we assume that synchronization is already completed
1248         //     and we may finalize initialization.
1249         GetPrefs()->SetString(prefs::kApplicationLocaleBackup, cur_locale);
1250         if (!new_locale.empty())
1251           GetPrefs()->SetString(prefs::kApplicationLocale, new_locale);
1252         else if (!backup_locale.empty())
1253           GetPrefs()->SetString(prefs::kApplicationLocale, backup_locale);
1254         do_update_pref = false;
1255       }
1256       break;
1257     }
1258     case APP_LOCALE_CHANGED_VIA_UNKNOWN:
1259     default: {
1260       NOTREACHED();
1261       break;
1262     }
1263   }
1264   if (do_update_pref)
1265     GetPrefs()->SetString(prefs::kApplicationLocale, new_locale);
1266   if (via != APP_LOCALE_CHANGED_VIA_PUBLIC_SESSION_LOGIN)
1267     local_state->SetString(prefs::kApplicationLocale, new_locale);
1268
1269   if (user_manager::UserManager::Get()->GetOwnerEmail() ==
1270       chromeos::ProfileHelper::Get()->GetUserByProfile(this)->email())
1271     local_state->SetString(prefs::kOwnerLocale, new_locale);
1272 }
1273
1274 void ProfileImpl::OnLogin() {
1275   if (locale_change_guard_ == NULL)
1276     locale_change_guard_.reset(new chromeos::LocaleChangeGuard(this));
1277   locale_change_guard_->OnLogin();
1278 }
1279
1280 void ProfileImpl::InitChromeOSPreferences() {
1281   chromeos_preferences_.reset(new chromeos::Preferences());
1282   chromeos_preferences_->Init(
1283       this, chromeos::ProfileHelper::Get()->GetUserByProfile(this));
1284 }
1285
1286 #endif  // defined(OS_CHROMEOS)
1287
1288 PrefProxyConfigTracker* ProfileImpl::GetProxyConfigTracker() {
1289   if (!pref_proxy_config_tracker_)
1290     pref_proxy_config_tracker_.reset(CreateProxyConfigTracker());
1291   return pref_proxy_config_tracker_.get();
1292 }
1293
1294 chrome_browser_net::Predictor* ProfileImpl::GetNetworkPredictor() {
1295   return predictor_;
1296 }
1297
1298 DevToolsNetworkController* ProfileImpl::GetDevToolsNetworkController() {
1299   return io_data_.GetDevToolsNetworkController();
1300 }
1301
1302 void ProfileImpl::ClearNetworkingHistorySince(
1303     base::Time time,
1304     const base::Closure& completion) {
1305   io_data_.ClearNetworkingHistorySince(time, completion);
1306 }
1307
1308 GURL ProfileImpl::GetHomePage() {
1309   // --homepage overrides any preferences.
1310   const CommandLine& command_line = *CommandLine::ForCurrentProcess();
1311   if (command_line.HasSwitch(switches::kHomePage)) {
1312     // TODO(evanm): clean up usage of DIR_CURRENT.
1313     //   http://code.google.com/p/chromium/issues/detail?id=60630
1314     // For now, allow this code to call getcwd().
1315     base::ThreadRestrictions::ScopedAllowIO allow_io;
1316
1317     base::FilePath browser_directory;
1318     PathService::Get(base::DIR_CURRENT, &browser_directory);
1319     GURL home_page(url_fixer::FixupRelativeFile(
1320         browser_directory,
1321         command_line.GetSwitchValuePath(switches::kHomePage)));
1322     if (home_page.is_valid())
1323       return home_page;
1324   }
1325
1326   if (GetPrefs()->GetBoolean(prefs::kHomePageIsNewTabPage))
1327     return GURL(chrome::kChromeUINewTabURL);
1328   GURL home_page(url_fixer::FixupURL(GetPrefs()->GetString(prefs::kHomePage),
1329                                      std::string()));
1330   if (!home_page.is_valid())
1331     return GURL(chrome::kChromeUINewTabURL);
1332   return home_page;
1333 }
1334
1335 void ProfileImpl::UpdateProfileUserNameCache() {
1336   ProfileManager* profile_manager = g_browser_process->profile_manager();
1337   ProfileInfoCache& cache = profile_manager->GetProfileInfoCache();
1338   size_t index = cache.GetIndexOfProfileWithPath(GetPath());
1339   if (index != std::string::npos) {
1340     std::string user_name =
1341         GetPrefs()->GetString(prefs::kGoogleServicesUsername);
1342     cache.SetUserNameOfProfileAtIndex(index, base::UTF8ToUTF16(user_name));
1343     ProfileMetrics::UpdateReportedProfilesStatistics(profile_manager);
1344   }
1345 }
1346
1347 void ProfileImpl::UpdateProfileSupervisedUserIdCache() {
1348   ProfileManager* profile_manager = g_browser_process->profile_manager();
1349   ProfileInfoCache& cache = profile_manager->GetProfileInfoCache();
1350   size_t index = cache.GetIndexOfProfileWithPath(GetPath());
1351   if (index != std::string::npos) {
1352     std::string supervised_user_id =
1353         GetPrefs()->GetString(prefs::kSupervisedUserId);
1354     cache.SetSupervisedUserIdOfProfileAtIndex(index, supervised_user_id);
1355     ProfileMetrics::UpdateReportedProfilesStatistics(profile_manager);
1356   }
1357 }
1358
1359 void ProfileImpl::UpdateProfileNameCache() {
1360   ProfileManager* profile_manager = g_browser_process->profile_manager();
1361   ProfileInfoCache& cache = profile_manager->GetProfileInfoCache();
1362   size_t index = cache.GetIndexOfProfileWithPath(GetPath());
1363   if (index != std::string::npos) {
1364     std::string profile_name =
1365         GetPrefs()->GetString(prefs::kProfileName);
1366     cache.SetNameOfProfileAtIndex(index, base::UTF8ToUTF16(profile_name));
1367     bool default_name =
1368         GetPrefs()->GetBoolean(prefs::kProfileUsingDefaultName);
1369     cache.SetProfileIsUsingDefaultNameAtIndex(index, default_name);
1370   }
1371 }
1372
1373 void ProfileImpl::UpdateProfileAvatarCache() {
1374   ProfileManager* profile_manager = g_browser_process->profile_manager();
1375   ProfileInfoCache& cache = profile_manager->GetProfileInfoCache();
1376   size_t index = cache.GetIndexOfProfileWithPath(GetPath());
1377   if (index != std::string::npos) {
1378     size_t avatar_index =
1379         GetPrefs()->GetInteger(prefs::kProfileAvatarIndex);
1380     cache.SetAvatarIconOfProfileAtIndex(index, avatar_index);
1381     bool default_avatar =
1382         GetPrefs()->GetBoolean(prefs::kProfileUsingDefaultAvatar);
1383     cache.SetProfileIsUsingDefaultAvatarAtIndex(index, default_avatar);
1384     bool gaia_avatar =
1385         GetPrefs()->GetBoolean(prefs::kProfileUsingGAIAAvatar);
1386     cache.SetIsUsingGAIAPictureOfProfileAtIndex(index, gaia_avatar);
1387   }
1388 }
1389
1390 void ProfileImpl::UpdateProfileIsEphemeralCache() {
1391   ProfileManager* profile_manager = g_browser_process->profile_manager();
1392   ProfileInfoCache& cache = profile_manager->GetProfileInfoCache();
1393   size_t index = cache.GetIndexOfProfileWithPath(GetPath());
1394   if (index != std::string::npos) {
1395     bool is_ephemeral = GetPrefs()->GetBoolean(prefs::kForceEphemeralProfiles);
1396     cache.SetProfileIsEphemeralAtIndex(index, is_ephemeral);
1397   }
1398 }
1399
1400 // Gets the cache parameters from the command line. If |is_media_context| is
1401 // set to true then settings for the media context type is what we need,
1402 // |cache_path| will be set to the user provided path, or will not be touched if
1403 // there is not an argument. |max_size| will be the user provided value or zero
1404 // by default.
1405 void ProfileImpl::GetCacheParameters(bool is_media_context,
1406                                      base::FilePath* cache_path,
1407                                      int* max_size) {
1408   DCHECK(cache_path);
1409   DCHECK(max_size);
1410   base::FilePath path(prefs_->GetFilePath(prefs::kDiskCacheDir));
1411   if (!path.empty())
1412     *cache_path = path;
1413   *max_size = is_media_context ? prefs_->GetInteger(prefs::kMediaCacheSize) :
1414                                  prefs_->GetInteger(prefs::kDiskCacheSize);
1415 }
1416
1417 PrefProxyConfigTracker* ProfileImpl::CreateProxyConfigTracker() {
1418 #if defined(OS_CHROMEOS)
1419   if (chromeos::ProfileHelper::IsSigninProfile(this)) {
1420     return ProxyServiceFactory::CreatePrefProxyConfigTrackerOfLocalState(
1421         g_browser_process->local_state());
1422   }
1423 #endif  // defined(OS_CHROMEOS)
1424   return ProxyServiceFactory::CreatePrefProxyConfigTrackerOfProfile(
1425       GetPrefs(), g_browser_process->local_state());
1426 }
1427
1428 scoped_ptr<domain_reliability::DomainReliabilityMonitor>
1429 ProfileImpl::CreateDomainReliabilityMonitor(PrefService* local_state) {
1430   domain_reliability::DomainReliabilityService* service =
1431       domain_reliability::DomainReliabilityServiceFactory::GetInstance()->
1432           GetForBrowserContext(this);
1433   if (!service)
1434     return scoped_ptr<domain_reliability::DomainReliabilityMonitor>();
1435
1436   return service->CreateMonitor(
1437       BrowserThread::GetMessageLoopProxyForThread(BrowserThread::IO),
1438       local_state,
1439       prefs::kMetricsReportingEnabled);
1440 }