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