chrome/browser/profiles/off_the_record_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/off_the_record_profile_impl.h"
   6
   7 #include "base/bind.h"
   8 #include "base/command_line.h"
   9 #include "base/compiler_specific.h"
  10 #include "base/files/file_path.h"
  11 #include "base/memory/scoped_ptr.h"
  12 #include "base/path_service.h"
  13 #include "base/prefs/json_pref_store.h"
  14 #include "base/strings/string_number_conversions.h"
  15 #include "base/strings/string_util.h"
  16 #include "build/build_config.h"
  17 #include "chrome/browser/background/background_contents_service_factory.h"
  18 #include "chrome/browser/browser_process.h"
  19 #include "chrome/browser/content_settings/host_content_settings_map.h"
  20 #include "chrome/browser/download/chrome_download_manager_delegate.h"
  21 #include "chrome/browser/download/download_service.h"
  22 #include "chrome/browser/download/download_service_factory.h"
  23 #include "chrome/browser/extensions/api/web_request/web_request_api.h"
  24 #include "chrome/browser/extensions/extension_service.h"
  25 #include "chrome/browser/extensions/extension_special_storage_policy.h"
  26 #include "chrome/browser/geolocation/chrome_geolocation_permission_context.h"
  27 #include "chrome/browser/geolocation/chrome_geolocation_permission_context_factory.h"
  28 #include "chrome/browser/guest_view/guest_view_manager.h"
  29 #include "chrome/browser/io_thread.h"
  30 #include "chrome/browser/media/chrome_midi_permission_context.h"
  31 #include "chrome/browser/media/chrome_midi_permission_context_factory.h"
  32 #include "chrome/browser/net/pref_proxy_config_tracker.h"
  33 #include "chrome/browser/net/proxy_service_factory.h"
  34 #include "chrome/browser/plugins/chrome_plugin_service_filter.h"
  35 #include "chrome/browser/plugins/plugin_prefs.h"
  36 #include "chrome/browser/prefs/incognito_mode_prefs.h"
  37 #include "chrome/browser/prefs/pref_service_syncable.h"
  38 #include "chrome/browser/themes/theme_service.h"
  39 #include "chrome/browser/ui/webui/extensions/extension_icon_source.h"
  40 #include "chrome/common/chrome_constants.h"
  41 #include "chrome/common/chrome_paths.h"
  42 #include "chrome/common/chrome_switches.h"
  43 #include "chrome/common/pref_names.h"
  44 #include "chrome/common/render_messages.h"
  45 #include "components/keyed_service/content/browser_context_dependency_manager.h"
  46 #include "components/user_prefs/user_prefs.h"
  47 #include "content/public/browser/browser_thread.h"
  48 #include "content/public/browser/host_zoom_map.h"
  49 #include "content/public/browser/render_process_host.h"
  50 #include "content/public/browser/storage_partition.h"
  51 #include "content/public/browser/url_data_source.h"
  52 #include "content/public/browser/web_contents.h"
  53 #include "extensions/browser/extension_system.h"
  54 #include "extensions/common/extension.h"
  55 #include "net/http/http_server_properties.h"
  56 #include "net/http/transport_security_state.h"
  57 #include "webkit/browser/database/database_tracker.h"
  58
  59 #if defined(OS_ANDROID)
  60 #include "chrome/browser/media/protected_media_identifier_permission_context.h"
  61 #include "chrome/browser/media/protected_media_identifier_permission_context_factory.h"
  62 #endif  // defined(OS_ANDROID)
  63
  64 #if defined(OS_ANDROID) || defined(OS_IOS)
  65 #include "base/prefs/scoped_user_pref_update.h"
  66 #include "chrome/browser/prefs/proxy_prefs.h"
  67 #endif  // defined(OS_ANDROID) || defined(OS_IOS)
  68
  69 #if defined(OS_CHROMEOS)
  70 #include "chrome/browser/chromeos/preferences.h"
  71 #include "chrome/browser/chromeos/profiles/profile_helper.h"
  72 #endif
  73
  74 #if defined(ENABLE_CONFIGURATION_POLICY) && !defined(OS_CHROMEOS)
  75 #include "chrome/browser/policy/cloud/user_cloud_policy_manager_factory.h"
  76 #endif
  77
  78 using content::BrowserThread;
  79 using content::DownloadManagerDelegate;
  80 using content::HostZoomMap;
  81
  82 namespace {
  83
  84 void NotifyOTRProfileCreatedOnIOThread(void* original_profile,
  85                                        void* otr_profile) {
  86   ExtensionWebRequestEventRouter::GetInstance()->OnOTRProfileCreated(
  87       original_profile, otr_profile);
  88 }
  89
  90 void NotifyOTRProfileDestroyedOnIOThread(void* original_profile,
  91                                          void* otr_profile) {
  92   ExtensionWebRequestEventRouter::GetInstance()->OnOTRProfileDestroyed(
  93       original_profile, otr_profile);
  94 }
  95
  96 }  // namespace
  97
  98 OffTheRecordProfileImpl::OffTheRecordProfileImpl(Profile* real_profile)
  99     : profile_(real_profile),
 100       prefs_(PrefServiceSyncable::IncognitoFromProfile(real_profile)),
 101       start_time_(Time::Now()) {
 102   // Register on BrowserContext.
 103   user_prefs::UserPrefs::Set(this, prefs_);
 104 }
 105
 106 void OffTheRecordProfileImpl::Init() {
 107   // The construction of OffTheRecordProfileIOData::Handle needs the profile
 108   // type returned by this->GetProfileType().  Since GetProfileType() is a
 109   // virtual member function, we cannot call the function defined in the most
 110   // derived class (e.g. GuestSessionProfile) until a ctor finishes.  Thus,
 111   // we have to instantiate OffTheRecordProfileIOData::Handle here after a ctor.
 112   InitIoData();
 113
 114 #if defined(ENABLE_CONFIGURATION_POLICY) && !defined(OS_CHROMEOS)
 115   // Because UserCloudPolicyManager is in a component, it cannot access
 116   // GetOriginalProfile. Instead, we have to inject this relation here.
 117   policy::UserCloudPolicyManagerFactory::RegisterForOffTheRecordBrowserContext(
 118       this->GetOriginalProfile(), this);
 119 #endif
 120
 121   BrowserContextDependencyManager::GetInstance()->CreateBrowserContextServices(
 122       this);
 123
 124   DCHECK_NE(IncognitoModePrefs::DISABLED,
 125             IncognitoModePrefs::GetAvailability(profile_->GetPrefs()));
 126
 127 #if defined(OS_ANDROID) || defined(OS_IOS)
 128   UseSystemProxy();
 129 #endif  // defined(OS_ANDROID) || defined(OS_IOS)
 130
 131   // TODO(oshima): Remove the need to eagerly initialize the request context
 132   // getter. chromeos::OnlineAttempt is illegally trying to access this
 133   // Profile member from a thread other than the UI thread, so we need to
 134   // prevent a race.
 135 #if defined(OS_CHROMEOS)
 136   GetRequestContext();
 137 #endif  // defined(OS_CHROMEOS)
 138
 139   InitHostZoomMap();
 140
 141   // Make the chrome//extension-icon/ resource available.
 142   extensions::ExtensionIconSource* icon_source =
 143       new extensions::ExtensionIconSource(profile_);
 144   content::URLDataSource::Add(this, icon_source);
 145
 146 #if defined(ENABLE_PLUGINS)
 147   ChromePluginServiceFilter::GetInstance()->RegisterResourceContext(
 148       PluginPrefs::GetForProfile(this).get(),
 149       io_data_->GetResourceContextNoInit());
 150 #endif
 151
 152   BrowserThread::PostTask(
 153       BrowserThread::IO, FROM_HERE,
 154       base::Bind(&NotifyOTRProfileCreatedOnIOThread, profile_, this));
 155 }
 156
 157 OffTheRecordProfileImpl::~OffTheRecordProfileImpl() {
 158   MaybeSendDestroyedNotification();
 159
 160 #if defined(ENABLE_PLUGINS)
 161   ChromePluginServiceFilter::GetInstance()->UnregisterResourceContext(
 162       io_data_->GetResourceContextNoInit());
 163 #endif
 164
 165   BrowserContextDependencyManager::GetInstance()->DestroyBrowserContextServices(
 166       this);
 167
 168   BrowserThread::PostTask(
 169       BrowserThread::IO, FROM_HERE,
 170       base::Bind(&NotifyOTRProfileDestroyedOnIOThread, profile_, this));
 171
 172   if (host_content_settings_map_.get())
 173     host_content_settings_map_->ShutdownOnUIThread();
 174
 175   if (pref_proxy_config_tracker_)
 176     pref_proxy_config_tracker_->DetachFromPrefService();
 177
 178   // Clears any data the network stack contains that may be related to the
 179   // OTR session.
 180   g_browser_process->io_thread()->ChangedToOnTheRecord();
 181 }
 182
 183 void OffTheRecordProfileImpl::InitIoData() {
 184   io_data_.reset(new OffTheRecordProfileIOData::Handle(this));
 185 }
 186
 187 void OffTheRecordProfileImpl::InitHostZoomMap() {
 188   HostZoomMap* host_zoom_map = HostZoomMap::GetForBrowserContext(this);
 189   HostZoomMap* parent_host_zoom_map =
 190       HostZoomMap::GetForBrowserContext(profile_);
 191   host_zoom_map->CopyFrom(parent_host_zoom_map);
 192   // Observe parent's HZM change for propagating change of parent's
 193   // change to this HZM.
 194   zoom_subscription_ = parent_host_zoom_map->AddZoomLevelChangedCallback(
 195       base::Bind(&OffTheRecordProfileImpl::OnZoomLevelChanged,
 196                  base::Unretained(this)));
 197 }
 198
 199 #if defined(OS_ANDROID) || defined(OS_IOS)
 200 void OffTheRecordProfileImpl::UseSystemProxy() {
 201   // Force the use of the system-assigned proxy when off the record.
 202   const char kProxyMode[] = "mode";
 203   const char kProxyServer[] = "server";
 204   const char kProxyBypassList[] = "bypass_list";
 205   const char kProxyPacUrl[] = "pac_url";
 206   DictionaryPrefUpdate update(prefs_, prefs::kProxy);
 207   base::DictionaryValue* dict = update.Get();
 208   dict->SetString(kProxyMode, ProxyModeToString(ProxyPrefs::MODE_SYSTEM));
 209   dict->SetString(kProxyPacUrl, "");
 210   dict->SetString(kProxyServer, "");
 211   dict->SetString(kProxyBypassList, "");
 212 }
 213 #endif  // defined(OS_ANDROID) || defined(OS_IOS)
 214
 215 std::string OffTheRecordProfileImpl::GetProfileName() {
 216   // Incognito profile should not return the profile name.
 217   return std::string();
 218 }
 219
 220 Profile::ProfileType OffTheRecordProfileImpl::GetProfileType() const {
 221   return INCOGNITO_PROFILE;
 222 }
 223
 224 base::FilePath OffTheRecordProfileImpl::GetPath() const {
 225   return profile_->GetPath();
 226 }
 227
 228 scoped_refptr<base::SequencedTaskRunner>
 229 OffTheRecordProfileImpl::GetIOTaskRunner() {
 230   return profile_->GetIOTaskRunner();
 231 }
 232
 233 bool OffTheRecordProfileImpl::IsOffTheRecord() const {
 234   return true;
 235 }
 236
 237 Profile* OffTheRecordProfileImpl::GetOffTheRecordProfile() {
 238   return this;
 239 }
 240
 241 void OffTheRecordProfileImpl::DestroyOffTheRecordProfile() {
 242   // Suicide is bad!
 243   NOTREACHED();
 244 }
 245
 246 bool OffTheRecordProfileImpl::HasOffTheRecordProfile() {
 247   return true;
 248 }
 249
 250 Profile* OffTheRecordProfileImpl::GetOriginalProfile() {
 251   return profile_;
 252 }
 253
 254 ExtensionService* OffTheRecordProfileImpl::GetExtensionService() {
 255   return extensions::ExtensionSystem::Get(this)->extension_service();
 256 }
 257
 258 ExtensionSpecialStoragePolicy*
 259     OffTheRecordProfileImpl::GetExtensionSpecialStoragePolicy() {
 260   return GetOriginalProfile()->GetExtensionSpecialStoragePolicy();
 261 }
 262
 263 bool OffTheRecordProfileImpl::IsManaged() {
 264   return GetOriginalProfile()->IsManaged();
 265 }
 266
 267 PrefService* OffTheRecordProfileImpl::GetPrefs() {
 268   return prefs_;
 269 }
 270
 271 PrefService* OffTheRecordProfileImpl::GetOffTheRecordPrefs() {
 272   return prefs_;
 273 }
 274
 275 DownloadManagerDelegate* OffTheRecordProfileImpl::GetDownloadManagerDelegate() {
 276   return DownloadServiceFactory::GetForBrowserContext(this)->
 277       GetDownloadManagerDelegate();
 278 }
 279
 280 net::URLRequestContextGetter* OffTheRecordProfileImpl::GetRequestContext() {
 281   return GetDefaultStoragePartition(this)->GetURLRequestContext();
 282 }
 283
 284 net::URLRequestContextGetter* OffTheRecordProfileImpl::CreateRequestContext(
 285     content::ProtocolHandlerMap* protocol_handlers,
 286     content::URLRequestInterceptorScopedVector request_interceptors) {
 287   return io_data_->CreateMainRequestContextGetter(
 288       protocol_handlers, request_interceptors.Pass()).get();
 289 }
 290
 291 net::URLRequestContextGetter*
 292     OffTheRecordProfileImpl::GetRequestContextForRenderProcess(
 293         int renderer_child_id) {
 294   content::RenderProcessHost* rph = content::RenderProcessHost::FromID(
 295       renderer_child_id);
 296   return rph->GetStoragePartition()->GetURLRequestContext();
 297 }
 298
 299 net::URLRequestContextGetter*
 300     OffTheRecordProfileImpl::GetMediaRequestContext() {
 301   // In OTR mode, media request context is the same as the original one.
 302   return GetRequestContext();
 303 }
 304
 305 net::URLRequestContextGetter*
 306     OffTheRecordProfileImpl::GetMediaRequestContextForRenderProcess(
 307         int renderer_child_id) {
 308   // In OTR mode, media request context is the same as the original one.
 309   return GetRequestContextForRenderProcess(renderer_child_id);
 310 }
 311
 312 net::URLRequestContextGetter*
 313 OffTheRecordProfileImpl::GetMediaRequestContextForStoragePartition(
 314     const base::FilePath& partition_path,
 315     bool in_memory) {
 316   return io_data_->GetIsolatedAppRequestContextGetter(partition_path, in_memory)
 317       .get();
 318 }
 319
 320 void OffTheRecordProfileImpl::RequestMidiSysExPermission(
 321       int render_process_id,
 322       int render_view_id,
 323       int bridge_id,
 324       const GURL& requesting_frame,
 325       bool user_gesture,
 326       const MidiSysExPermissionCallback& callback) {
 327   ChromeMidiPermissionContext* context =
 328       ChromeMidiPermissionContextFactory::GetForProfile(this);
 329   context->RequestMidiSysExPermission(render_process_id,
 330                                       render_view_id,
 331                                       bridge_id,
 332                                       requesting_frame,
 333                                       user_gesture,
 334                                       callback);
 335 }
 336
 337 void OffTheRecordProfileImpl::CancelMidiSysExPermissionRequest(
 338     int render_process_id,
 339     int render_view_id,
 340     int bridge_id,
 341     const GURL& requesting_frame) {
 342   ChromeMidiPermissionContext* context =
 343       ChromeMidiPermissionContextFactory::GetForProfile(this);
 344   context->CancelMidiSysExPermissionRequest(
 345       render_process_id, render_view_id, bridge_id, requesting_frame);
 346 }
 347
 348 void OffTheRecordProfileImpl::RequestProtectedMediaIdentifierPermission(
 349     int render_process_id,
 350     int render_view_id,
 351     const GURL& origin,
 352     const ProtectedMediaIdentifierPermissionCallback& callback) {
 353 #if defined(OS_ANDROID)
 354   ProtectedMediaIdentifierPermissionContext* context =
 355       ProtectedMediaIdentifierPermissionContextFactory::GetForProfile(this);
 356   context->RequestProtectedMediaIdentifierPermission(render_process_id,
 357                                                      render_view_id,
 358                                                      origin,
 359                                                      callback);
 360 #else
 361   NOTIMPLEMENTED();
 362   callback.Run(false);
 363 #endif  // defined(OS_ANDROID)
 364 }
 365
 366 void OffTheRecordProfileImpl::CancelProtectedMediaIdentifierPermissionRequests(
 367     int render_process_id,
 368     int render_view_id,
 369     const GURL& origin) {
 370 #if defined(OS_ANDROID)
 371   ProtectedMediaIdentifierPermissionContext* context =
 372       ProtectedMediaIdentifierPermissionContextFactory::GetForProfile(this);
 373   context->CancelProtectedMediaIdentifierPermissionRequests(
 374       render_process_id, render_view_id, origin);
 375 #else
 376   NOTIMPLEMENTED();
 377 #endif  // defined(OS_ANDROID)
 378 }
 379
 380 net::URLRequestContextGetter*
 381     OffTheRecordProfileImpl::GetRequestContextForExtensions() {
 382   return io_data_->GetExtensionsRequestContextGetter().get();
 383 }
 384
 385 net::URLRequestContextGetter*
 386 OffTheRecordProfileImpl::CreateRequestContextForStoragePartition(
 387     const base::FilePath& partition_path,
 388     bool in_memory,
 389     content::ProtocolHandlerMap* protocol_handlers,
 390     content::URLRequestInterceptorScopedVector request_interceptors) {
 391   return io_data_->CreateIsolatedAppRequestContextGetter(
 392       partition_path,
 393       in_memory,
 394       protocol_handlers,
 395       request_interceptors.Pass()).get();
 396 }
 397
 398 content::ResourceContext* OffTheRecordProfileImpl::GetResourceContext() {
 399   return io_data_->GetResourceContext();
 400 }
 401
 402 net::SSLConfigService* OffTheRecordProfileImpl::GetSSLConfigService() {
 403   return profile_->GetSSLConfigService();
 404 }
 405
 406 HostContentSettingsMap* OffTheRecordProfileImpl::GetHostContentSettingsMap() {
 407   // Retrieve the host content settings map of the parent profile in order to
 408   // ensure the preferences have been migrated.
 409   profile_->GetHostContentSettingsMap();
 410   if (!host_content_settings_map_.get()) {
 411     host_content_settings_map_ = new HostContentSettingsMap(GetPrefs(), true);
 412 #if defined(ENABLE_EXTENSIONS)
 413     ExtensionService* extension_service = GetExtensionService();
 414     if (extension_service)
 415       host_content_settings_map_->RegisterExtensionService(extension_service);
 416 #endif
 417   }
 418   return host_content_settings_map_.get();
 419 }
 420
 421 content::GeolocationPermissionContext*
 422     OffTheRecordProfileImpl::GetGeolocationPermissionContext() {
 423   return ChromeGeolocationPermissionContextFactory::GetForProfile(this);
 424 }
 425
 426 content::BrowserPluginGuestManager*
 427     OffTheRecordProfileImpl::GetGuestManager() {
 428   return GuestViewManager::FromBrowserContext(this);
 429 }
 430
 431 quota::SpecialStoragePolicy*
 432     OffTheRecordProfileImpl::GetSpecialStoragePolicy() {
 433   return GetExtensionSpecialStoragePolicy();
 434 }
 435
 436 bool OffTheRecordProfileImpl::IsSameProfile(Profile* profile) {
 437   return (profile == this) || (profile == profile_);
 438 }
 439
 440 Time OffTheRecordProfileImpl::GetStartTime() const {
 441   return start_time_;
 442 }
 443
 444 history::TopSites* OffTheRecordProfileImpl::GetTopSitesWithoutCreating() {
 445   return NULL;
 446 }
 447
 448 history::TopSites* OffTheRecordProfileImpl::GetTopSites() {
 449   return NULL;
 450 }
 451
 452 void OffTheRecordProfileImpl::SetExitType(ExitType exit_type) {
 453 }
 454
 455 base::FilePath OffTheRecordProfileImpl::last_selected_directory() {
 456   const base::FilePath& directory = last_selected_directory_;
 457   if (directory.empty()) {
 458     return profile_->last_selected_directory();
 459   }
 460   return directory;
 461 }
 462
 463 void OffTheRecordProfileImpl::set_last_selected_directory(
 464     const base::FilePath& path) {
 465   last_selected_directory_ = path;
 466 }
 467
 468 bool OffTheRecordProfileImpl::WasCreatedByVersionOrLater(
 469     const std::string& version) {
 470   return profile_->WasCreatedByVersionOrLater(version);
 471 }
 472
 473 Profile::ExitType OffTheRecordProfileImpl::GetLastSessionExitType() {
 474   return profile_->GetLastSessionExitType();
 475 }
 476
 477 #if defined(OS_CHROMEOS)
 478 void OffTheRecordProfileImpl::ChangeAppLocale(const std::string& locale,
 479                                               AppLocaleChangedVia) {
 480 }
 481
 482 void OffTheRecordProfileImpl::OnLogin() {
 483 }
 484
 485 void OffTheRecordProfileImpl::InitChromeOSPreferences() {
 486   // The incognito profile shouldn't have Chrome OS's preferences.
 487   // The preferences are associated with the regular user profile.
 488 }
 489 #endif  // defined(OS_CHROMEOS)
 490
 491 PrefProxyConfigTracker* OffTheRecordProfileImpl::GetProxyConfigTracker() {
 492   if (!pref_proxy_config_tracker_)
 493     pref_proxy_config_tracker_.reset(CreateProxyConfigTracker());
 494   return pref_proxy_config_tracker_.get();
 495 }
 496
 497 chrome_browser_net::Predictor* OffTheRecordProfileImpl::GetNetworkPredictor() {
 498   // We do not store information about websites visited in OTR profiles which
 499   // is necessary for a Predictor, so we do not have a Predictor at all.
 500   return NULL;
 501 }
 502
 503 DevToolsNetworkController*
 504 OffTheRecordProfileImpl::GetDevToolsNetworkController() {
 505   return io_data_->GetDevToolsNetworkController();
 506 }
 507
 508 void OffTheRecordProfileImpl::ClearNetworkingHistorySince(
 509     base::Time time,
 510     const base::Closure& completion) {
 511   // Nothing to do here, our transport security state is read-only.
 512   // Still, fire the callback to indicate we have finished, otherwise the
 513   // BrowsingDataRemover will never be destroyed and the dialog will never be
 514   // closed. We must do this asynchronously in order to avoid reentrancy issues.
 515   if (!completion.is_null()) {
 516     BrowserThread::PostTask(BrowserThread::UI, FROM_HERE, completion);
 517   }
 518 }
 519
 520 void OffTheRecordProfileImpl::ClearDomainReliabilityMonitor(
 521     domain_reliability::DomainReliabilityClearMode mode,
 522     const base::Closure& completion) {
 523   // Incognito profiles don't have Domain Reliability Monitors, so there's
 524   // nothing to do here.
 525   if (!completion.is_null()) {
 526     BrowserThread::PostTask(BrowserThread::UI, FROM_HERE, completion);
 527   }
 528 }
 529
 530 GURL OffTheRecordProfileImpl::GetHomePage() {
 531   return profile_->GetHomePage();
 532 }
 533
 534 #if defined(OS_CHROMEOS)
 535 // Special case of the OffTheRecordProfileImpl which is used while Guest
 536 // session in CrOS.
 537 class GuestSessionProfile : public OffTheRecordProfileImpl {
 538  public:
 539   explicit GuestSessionProfile(Profile* real_profile)
 540       : OffTheRecordProfileImpl(real_profile) {
 541   }
 542
 543   virtual ProfileType GetProfileType() const OVERRIDE {
 544     return GUEST_PROFILE;
 545   }
 546
 547   virtual void InitChromeOSPreferences() OVERRIDE {
 548     chromeos_preferences_.reset(new chromeos::Preferences());
 549     chromeos_preferences_->Init(static_cast<PrefServiceSyncable*>(GetPrefs()),
 550                                 chromeos::UserManager::Get()->GetActiveUser());
 551   }
 552
 553  private:
 554   // The guest user should be able to customize Chrome OS preferences.
 555   scoped_ptr<chromeos::Preferences> chromeos_preferences_;
 556 };
 557 #endif
 558
 559 Profile* Profile::CreateOffTheRecordProfile() {
 560   OffTheRecordProfileImpl* profile = NULL;
 561 #if defined(OS_CHROMEOS)
 562   if (IsGuestSession())
 563     profile = new GuestSessionProfile(this);
 564 #endif
 565   if (!profile)
 566     profile = new OffTheRecordProfileImpl(this);
 567   profile->Init();
 568   return profile;
 569 }
 570
 571 void OffTheRecordProfileImpl::OnZoomLevelChanged(
 572     const HostZoomMap::ZoomLevelChange& change) {
 573   HostZoomMap* host_zoom_map = HostZoomMap::GetForBrowserContext(this);
 574   switch (change.mode) {
 575     case HostZoomMap::ZOOM_CHANGED_TEMPORARY_ZOOM:
 576        return;
 577     case HostZoomMap::ZOOM_CHANGED_FOR_HOST:
 578        host_zoom_map->SetZoomLevelForHost(change.host, change.zoom_level);
 579        return;
 580     case HostZoomMap::ZOOM_CHANGED_FOR_SCHEME_AND_HOST:
 581        host_zoom_map->SetZoomLevelForHostAndScheme(change.scheme,
 582            change.host,
 583            change.zoom_level);
 584        return;
 585   }
 586 }
 587
 588 PrefProxyConfigTracker* OffTheRecordProfileImpl::CreateProxyConfigTracker() {
 589 #if defined(OS_CHROMEOS)
 590   if (chromeos::ProfileHelper::IsSigninProfile(this)) {
 591     return ProxyServiceFactory::CreatePrefProxyConfigTrackerOfLocalState(
 592         g_browser_process->local_state());
 593   }
 594 #endif  // defined(OS_CHROMEOS)
 595   return ProxyServiceFactory::CreatePrefProxyConfigTrackerOfProfile(
 596       GetPrefs(), g_browser_process->local_state());
 597 }