Migrate HostZoomMap to live in StoragePartition.

content/browser/host_zoom_map_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 "content/browser/host_zoom_map_impl.h"
 
 #include <algorithm>
 #include <cmath>
 
 #include "base/strings/string_piece.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/values.h"
 #include "content/browser/frame_host/navigation_entry_impl.h"
 #include "content/browser/renderer_host/render_process_host_impl.h"
 #include "content/browser/renderer_host/render_view_host_impl.h"
 #include "content/browser/web_contents/web_contents_impl.h"
 #include "content/common/view_messages.h"
 #include "content/public/browser/browser_context.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/notification_types.h"
 #include "content/public/browser/resource_context.h"
+#include "content/public/browser/site_instance.h"
+#include "content/public/browser/storage_partition.h"
 #include "content/public/common/page_zoom.h"
 #include "net/base/net_util.h"
 
-static const char* kHostZoomMapKeyName = "content_host_zoom_map";
-
 namespace content {
 
 namespace {
 
 std::string GetHostFromProcessView(int render_process_id, int render_view_id) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   RenderViewHost* render_view_host =
       RenderViewHost::FromID(render_process_id, render_view_id);
   if (!render_view_host)
     return std::string();
 
   WebContents* web_contents = WebContents::FromRenderViewHost(render_view_host);
 
   NavigationEntry* entry =
       web_contents->GetController().GetLastCommittedEntry();
   if (!entry)
     return std::string();
 
   return net::GetHostOrSpecFromURL(entry->GetURL());
 }
 
 }  // namespace
 
 HostZoomMap* HostZoomMap::GetForBrowserContext(BrowserContext* context) {
-  HostZoomMapImpl* rv = static_cast<HostZoomMapImpl*>(
-      context->GetUserData(kHostZoomMapKeyName));
-  if (!rv) {
-    rv = new HostZoomMapImpl();
-    context->SetUserData(kHostZoomMapKeyName, rv);
-  }
-  return rv;
+  StoragePartition* partition =
+      BrowserContext::GetDefaultStoragePartition(context);
+  DCHECK(partition);
+  return partition->GetHostZoomMap();
+}
+
+HostZoomMap* HostZoomMap::Get(SiteInstance* instance) {
+  StoragePartition* partition = BrowserContext::GetStoragePartition(
+      instance->GetBrowserContext(), instance);
+  DCHECK(partition);
+  return partition->GetHostZoomMap();
+}
+
+HostZoomMap* HostZoomMap::GetForWebContents(const WebContents* contents) {
+  StoragePartition* partition =
+      BrowserContext::GetStoragePartition(contents->GetBrowserContext(),
+                                          contents->GetSiteInstance());
+  DCHECK(partition);
+  return partition->GetHostZoomMap();
 }
 
 // Helper function for setting/getting zoom levels for WebContents without
 // having to import HostZoomMapImpl everywhere.
 double HostZoomMap::GetZoomLevel(const WebContents* web_contents) {
   HostZoomMapImpl* host_zoom_map = static_cast<HostZoomMapImpl*>(
-      HostZoomMap::GetForBrowserContext(web_contents->GetBrowserContext()));
+      HostZoomMap::GetForWebContents(web_contents));
   return host_zoom_map->GetZoomLevelForWebContents(
       *static_cast<const WebContentsImpl*>(web_contents));
 }
 
 void HostZoomMap::SetZoomLevel(const WebContents* web_contents, double level) {
   HostZoomMapImpl* host_zoom_map = static_cast<HostZoomMapImpl*>(
-      HostZoomMap::GetForBrowserContext(web_contents->GetBrowserContext()));
+      HostZoomMap::GetForWebContents(web_contents));
   host_zoom_map->SetZoomLevelForWebContents(
       *static_cast<const WebContentsImpl*>(web_contents), level);
 }
 
-HostZoomMapImpl::HostZoomMapImpl()
-    : default_zoom_level_(0.0) {
+HostZoomMapImpl::HostZoomMapImpl(double default_zoom_level)

[Fady Samuel, 2014/08/13 19:45:43]

Why do we take in a default zoom level here? 

[wjmaclean, 2014/08/14 18:18:21]

Since we know the default zoom level at construction time, I figured it is
clearer to include this in the constructor; it eliminates the need for a
default-default-zoom level.

+    : default_zoom_level_(default_zoom_level) {
   registrar_.Add(
       this, NOTIFICATION_RENDER_VIEW_HOST_WILL_CLOSE_RENDER_VIEW,
       NotificationService::AllSources());
 }
 
 void HostZoomMapImpl::CopyFrom(HostZoomMap* copy_interface) {
   // This can only be called on the UI thread to avoid deadlocks, otherwise
   //   UI: a.CopyFrom(b);
   //   IO: b.CopyFrom(a);
   // can deadlock.
@@ skipping 44 matching lines @@
         scheme_host_zoom_levels_.find(scheme));
     if (scheme_iterator != scheme_host_zoom_levels_.end()) {
       HostZoomLevels::const_iterator i(scheme_iterator->second.find(host));
       if (i != scheme_iterator->second.end())
         return i->second;
     }
   }
   return GetZoomLevelForHost(host);
 }
 
+scoped_ptr<base::DictionaryValue> HostZoomMapImpl::ZoomLevelDictionary() const {
+  base::DictionaryValue* dictionary = new base::DictionaryValue();
+  {
+    base::AutoLock auto_lock(lock_);
+
+    for (HostZoomLevels::const_iterator i = host_zoom_levels_.begin();
+         i != host_zoom_levels_.end();
+         ++i) {
+      if (!ZoomValuesEqual(i->second, default_zoom_level_)) {

[Fady Samuel, 2014/08/13 19:45:42]

if (ZoomValuesEqual(i->second, default_zoom_level_))
  continue;

[wjmaclean, 2014/08/14 18:18:21]

Done.

+        dictionary->SetDoubleWithoutPathExpansion(i->first /* host */,
+                                                  i->second /* level */);
+      }
+    }
+  }
+  return scoped_ptr<base::DictionaryValue>(dictionary);
+}
+
+// TODO(wjmaclean) The only non-test caller of this just throws away the non-
+// host entries and makes a dictionary, and so could probably be converted to
+// use ZoomLevelDictionary() instead. The test might also be amenable to
+// something similar.
 HostZoomMap::ZoomLevelVector HostZoomMapImpl::GetAllZoomLevels() const {
   HostZoomMap::ZoomLevelVector result;
   {
     base::AutoLock auto_lock(lock_);
     result.reserve(host_zoom_levels_.size() + scheme_host_zoom_levels_.size());
     for (HostZoomLevels::const_iterator i = host_zoom_levels_.begin();
          i != host_zoom_levels_.end();
          ++i) {
       ZoomLevelChange change = {HostZoomMap::ZOOM_CHANGED_FOR_HOST,
                                 i->first,       // host
@@ skipping 214 matching lines @@
       GetZoomLevelForHost(
           GetHostFromProcessView(render_process_id, render_view_id))));
 }
 
 void HostZoomMapImpl::SendZoomLevelChange(const std::string& scheme,
                                           const std::string& host,
                                           double level) {
   for (RenderProcessHost::iterator i(RenderProcessHost::AllHostsIterator());
        !i.IsAtEnd(); i.Advance()) {
     RenderProcessHost* render_process_host = i.GetCurrentValue();
-    if (HostZoomMap::GetForBrowserContext(
-            render_process_host->GetBrowserContext()) == this) {
+    // TODO(wjmaclean) This will need to be cleaned up when
+    // RenderProcessHost::GetStoragePartition() goes away. Perhaps have
+    // RenderProcessHost expose a GetHostZoomMap() function?
+    if (render_process_host->GetStoragePartition()->GetHostZoomMap() == this) {
       render_process_host->Send(
           new ViewMsg_SetZoomLevelForCurrentURL(scheme, host, level));
     }
   }
 }
 
 HostZoomMapImpl::~HostZoomMapImpl() {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 }
 
+
 }  // namespace content