Move creation and ownership of HostZoomMap to content instead of having every embedder do this.

chrome/browser/profiles/profile_impl.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "chrome/browser/profiles/profile_impl.h"
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/compiler_specific.h"
 #include "base/environment.h"
@@ skipping 228 matching lines @@
 }
 
 ProfileImpl::ProfileImpl(const FilePath& path,
                          Profile::Delegate* delegate)
     : path_(path),
       ALLOW_THIS_IN_INITIALIZER_LIST(visited_link_event_listener_(
           new VisitedLinkEventListener(this))),
       ALLOW_THIS_IN_INITIALIZER_LIST(io_data_(this)),
       extension_devtools_manager_(NULL),
       host_content_settings_map_(NULL),
-      host_zoom_map_(NULL),
       history_service_created_(false),
       favicon_service_created_(false),
       created_web_data_service_(false),
       created_password_store_(false),
       start_time_(Time::Now()),
 #if defined(OS_WIN)
       checked_instant_promo_(false),
 #endif
       delegate_(delegate),
       predictor_(NULL),
@@ skipping 125 matching lines @@
   FilePath app_path = GetPath().Append(chrome::kIsolatedAppStateDirname);
 
   SessionStartupPref startup_pref =
       BrowserInit::GetSessionStartupPref(*CommandLine::ForCurrentProcess(),
                                          this);
   bool restore_old_session_cookies =
       session_restore_enabled_ &&
       (!DidLastSessionExitCleanly() ||
        startup_pref.type == SessionStartupPref::LAST);
 
+  InitHostZoomMap();
+
   // Make sure we initialize the ProfileIOData after everything else has been
   // initialized that we might be reading from the IO thread.
 
   io_data_.Init(cookie_path, origin_bound_cert_path, cache_path,
                 cache_max_size, media_cache_path, media_cache_max_size,
                 extensions_cookie_path, app_path, predictor_,
                 g_browser_process->local_state(),
                 g_browser_process->io_thread(),
                 restore_old_session_cookies);
 
   ChromePluginServiceFilter::GetInstance()->RegisterResourceContext(
       PluginPrefs::GetForProfile(this),
       io_data_.GetResourceContextNoInit());
 
   // Creation has been finished.
   if (delegate_)
     delegate_->OnProfileCreated(this, true);
 
   content::NotificationService::current()->Notify(
       chrome::NOTIFICATION_PROFILE_CREATED,
       content::Source<Profile>(this),
       content::NotificationService::NoDetails());
 }
 
+void ProfileImpl::InitHostZoomMap() {
+  HostZoomMap* host_zoom_map = HostZoomMap::GetForBrowserContext(this);
+  host_zoom_map->SetDefaultZoomLevel(
+      prefs_->GetDouble(prefs::kDefaultZoomLevel));
+
+  const DictionaryValue* host_zoom_dictionary =
+      prefs_->GetDictionary(prefs::kPerHostZoomLevels);
+  // Careful: The returned value could be NULL if the pref has never been set.
+  if (host_zoom_dictionary != NULL) {
+    for (DictionaryValue::key_iterator i(host_zoom_dictionary->begin_keys());
+         i != host_zoom_dictionary->end_keys(); ++i) {
+      const std::string& host(*i);
+      double zoom_level = 0;
+
+      bool success = host_zoom_dictionary->GetDoubleWithoutPathExpansion(
+          host, &zoom_level);
+      DCHECK(success);
+      host_zoom_map->SetZoomLevel(host, zoom_level);
+    }
+  }
+
+  registrar_.Add(this, content::NOTIFICATION_ZOOM_LEVEL_CHANGED,
+               content::Source<HostZoomMap>(host_zoom_map));
+}
+
 void ProfileImpl::InitExtensions(bool extensions_enabled) {
   if (user_script_master_ || extension_service_.get())
     return;  // Already initialized.
 
   const CommandLine* command_line = CommandLine::ForCurrentProcess();
   if (command_line->HasSwitch(
       switches::kEnableExtensionTimelineApi)) {
     extension_devtools_manager_ = new ExtensionDevToolsManager(this);
   }
 
@@ skipping 436 matching lines @@
 }
 
 HostContentSettingsMap* ProfileImpl::GetHostContentSettingsMap() {
   if (!host_content_settings_map_.get()) {
     host_content_settings_map_ = new HostContentSettingsMap(
         GetPrefs(), GetExtensionService(), false);
   }
   return host_content_settings_map_.get();
 }
 
-HostZoomMap* ProfileImpl::GetHostZoomMap() {
-  if (!host_zoom_map_) {
-    host_zoom_map_ = HostZoomMap::Create();
-    host_zoom_map_->SetDefaultZoomLevel(
-        GetPrefs()->GetDouble(prefs::kDefaultZoomLevel));
-
-    const DictionaryValue* host_zoom_dictionary =
-        prefs_->GetDictionary(prefs::kPerHostZoomLevels);
-    // Careful: The returned value could be NULL if the pref has never been set.
-    if (host_zoom_dictionary != NULL) {
-      for (DictionaryValue::key_iterator i(host_zoom_dictionary->begin_keys());
-           i != host_zoom_dictionary->end_keys(); ++i) {
-        const std::string& host(*i);
-        double zoom_level = 0;
-
-        bool success = host_zoom_dictionary->GetDoubleWithoutPathExpansion(
-            host, &zoom_level);
-        DCHECK(success);
-        host_zoom_map_->SetZoomLevel(host, zoom_level);
-      }
-    }
-
-    registrar_.Add(this, content::NOTIFICATION_ZOOM_LEVEL_CHANGED,
-                 content::Source<HostZoomMap>(host_zoom_map_));
-  }
-  return host_zoom_map_.get();
-}
-
 content::GeolocationPermissionContext*
     ProfileImpl::GetGeolocationPermissionContext() {
   if (!geolocation_permission_context_.get()) {
     geolocation_permission_context_ =
         new ChromeGeolocationPermissionContext(this);
   }
   return geolocation_permission_context_.get();
 }
 
 content::SpeechInputPreferences* ProfileImpl::GetSpeechInputPreferences() {
@@ skipping 291 matching lines @@
       } else if (*pref_name_in == prefs::kClearSiteDataOnExit) {
         clear_local_state_on_exit_ =
             prefs->GetBoolean(prefs::kClearSiteDataOnExit);
       } else if (*pref_name_in == prefs::kGoogleServicesUsername) {
         UpdateProfileUserNameCache();
       } else if (*pref_name_in == prefs::kProfileAvatarIndex) {
         UpdateProfileAvatarCache();
       } else if (*pref_name_in == prefs::kProfileName) {
         UpdateProfileNameCache();
       } else if (*pref_name_in == prefs::kDefaultZoomLevel) {
-          GetHostZoomMap()->SetDefaultZoomLevel(
+          HostZoomMap::GetForBrowserContext(this)->SetDefaultZoomLevel(
               prefs->GetDouble(prefs::kDefaultZoomLevel));
       }
       break;
     }
     case chrome::NOTIFICATION_BOOKMARK_MODEL_LOADED:
       // Causes lazy-load if sync is enabled.
       ProfileSyncServiceFactory::GetInstance()->GetForProfile(this);
       registrar_.Remove(this, chrome::NOTIFICATION_BOOKMARK_MODEL_LOADED,
                         content::Source<Profile>(this));
       break;
     case content::NOTIFICATION_ZOOM_LEVEL_CHANGED: {
       const std::string& host =
           *(content::Details<const std::string>(details).ptr());
       if (!host.empty()) {
-        double level = host_zoom_map_->GetZoomLevel(host);
+        HostZoomMap* host_zoom_map = HostZoomMap::GetForBrowserContext(this);
+        double level = host_zoom_map->GetZoomLevel(host);
         DictionaryPrefUpdate update(prefs_.get(), prefs::kPerHostZoomLevels);
         DictionaryValue* host_zoom_dictionary = update.Get();
-        if (level == host_zoom_map_->GetDefaultZoomLevel()) {
+        if (level == host_zoom_map->GetDefaultZoomLevel()) {
           host_zoom_dictionary->RemoveWithoutPathExpansion(host, NULL);
         } else {
           host_zoom_dictionary->SetWithoutPathExpansion(
               host, Value::CreateDoubleValue(level));
         }
       }
       break;
     }
     default:
       NOTREACHED();
@@ skipping 240 matching lines @@
                                      FilePath* cache_path,
                                      int* max_size) {
   DCHECK(cache_path);
   DCHECK(max_size);
   FilePath path(prefs_->GetFilePath(prefs::kDiskCacheDir));
   if (!path.empty())
     *cache_path = path;
   *max_size = is_media_context ? prefs_->GetInteger(prefs::kMediaCacheSize) :
                                  prefs_->GetInteger(prefs::kDiskCacheSize);
 }