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 "content/public/common/url_constants.h"
 #include "net/base/net_util.h"
 
 namespace content {
 
 namespace {
 
-const char kHostZoomMapKeyName[] = "content_host_zoom_map";
-
 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 =
@@ skipping 11 matching lines @@
     case PAGE_TYPE_ERROR:
       return GURL(kUnreachableWebDataURL);
     // TODO(wjmaclean): In future, give interstitial pages special treatment as
     // well.
     default:
       return entry->GetURL();
   }
 }
 
 HostZoomMap* HostZoomMap::GetDefaultForBrowserContext(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::GetDefaultForBrowserContext(
-          web_contents->GetBrowserContext()));
+  HostZoomMapImpl* host_zoom_map = static_cast<HostZoomMapImpl*>(
+      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::GetDefaultForBrowserContext(
-          web_contents->GetBrowserContext()));
+  HostZoomMapImpl* host_zoom_map = static_cast<HostZoomMapImpl*>(
+      HostZoomMap::GetForWebContents(web_contents));
   host_zoom_map->SetZoomLevelForWebContents(
       *static_cast<const WebContentsImpl*>(web_contents), level);
 }
 
 void HostZoomMap::SendErrorPageZoomLevelRefresh(
     const WebContents* web_contents) {
   HostZoomMapImpl* host_zoom_map =
       static_cast<HostZoomMapImpl*>(HostZoomMap::GetDefaultForBrowserContext(
           web_contents->GetBrowserContext()));
   host_zoom_map->SendErrorPageZoomLevelRefresh();
@@ skipping 139 matching lines @@
   HostZoomMap::ZoomLevelChange change;
   change.mode = HostZoomMap::ZOOM_CHANGED_FOR_SCHEME_AND_HOST;
   change.host = host;
   change.scheme = scheme;
   change.zoom_level = level;
 
   zoom_level_changed_callbacks_.Notify(change);
 }
 
 double HostZoomMapImpl::GetDefaultZoomLevel() const {
+  // This function may be called on different threads, and presumably there's
+  // no guarantee setting a double is an atomic op on all platforms.

[Charlie Reis, 2014/11/11 05:29:22]

I think you missed the change here, since this still says "setting."

Also, your comment that this class does get accessed from multiple threads has
me worried.  Why is the setter safe without a lock when the getter isn't?  The
same is true of a lot of methods here.  I'm assuming there's a policy for which
methods are safe to call from multiple threads and which aren't, but I don't see
it.

[wjmaclean, 2014/11/11 19:20:52]

I must be losing my mind ... thought I had fixed this too, but done! :-)
I don't know what, if any, policy exists. This is how I found the code, and I
must admit I am not aware of any cases where any of the default zoom level
values are accessed/changed on other threads. There is one instance of reading
per-host zoom levels on the IO thread that I am aware of.

Perhaps we don't need this, but perhaps we should (in absence of any
thread-checking) always lock for default zoom level as well?

Let's try thread checking for now. That sends a clear message about policy as
well.

[Charlie Reis, 2014/11/11 23:52:01]

Thanks-- that sounds good to me.

+  base::AutoLock auto_lock(lock_);
   return default_zoom_level_;
 }
 
 void HostZoomMapImpl::SetDefaultZoomLevel(double level) {
   default_zoom_level_ = level;
 }
 
 scoped_ptr<HostZoomMap::Subscription>
 HostZoomMapImpl::AddZoomLevelChangedCallback(
     const ZoomLevelChangedCallback& callback) {
@@ skipping 133 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::GetDefaultForBrowserContext(
-            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));
     }
   }
 }
 
 void HostZoomMapImpl::SendErrorPageZoomLevelRefresh() {
   GURL error_url(kUnreachableWebDataURL);
   std::string host = net::GetHostOrSpecFromURL(error_url);
   double error_page_zoom_level = GetZoomLevelForHost(host);
 
   SendZoomLevelChange(std::string(), host, error_page_zoom_level);
 }
 
 HostZoomMapImpl::~HostZoomMapImpl() {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 }
 
 }  // namespace content