Zoom Extension API (content changes)

content/browser/host_zoom_map_impl.cc

Index: content/browser/host_zoom_map_impl.cc
diff --git a/content/browser/host_zoom_map_impl.cc b/content/browser/host_zoom_map_impl.cc
index a14b163c4ceb014fe06e94943b387992a62ca59c..c91f63f4e8a28128b002e5fc136279958834e510 100644
--- a/content/browser/host_zoom_map_impl.cc
+++ b/content/browser/host_zoom_map_impl.cc
@@ -87,6 +87,22 @@ double HostZoomMapImpl::GetZoomLevelForHost(const std::string& host) const {
   return (i == host_zoom_levels_.end()) ? default_zoom_level_ : i->second;
 }
 
+bool HostZoomMapImpl::HasZoomLevelInMap(const std::string& scheme,
+                                        const std::string& host) const {
+  base::AutoLock auto_lock(lock_);
+
+  SchemeHostZoomLevels::const_iterator scheme_iterator(
+      scheme_host_zoom_levels_.find(scheme));
+
+  const HostZoomLevels& zoom_levels =
+      (scheme_iterator != scheme_host_zoom_levels_.end())
+          ? scheme_iterator->second
+          : host_zoom_levels_;
+
+  HostZoomLevels::const_iterator i(zoom_levels.find(host));
+  return i != zoom_levels.end();
+}
+
 double HostZoomMapImpl::GetZoomLevelForHostAndScheme(
     const std::string& scheme,
     const std::string& host) const {
@@ -152,16 +168,8 @@ void HostZoomMapImpl::SetZoomLevelForHost(const std::string& host,
       host_zoom_levels_[host] = level;
   }
 
-  // Notify renderers from this browser context.
-  for (RenderProcessHost::iterator i(RenderProcessHost::AllHostsIterator());
-       !i.IsAtEnd(); i.Advance()) {
-    RenderProcessHost* render_process_host = i.GetCurrentValue();
-    if (HostZoomMap::GetForBrowserContext(
-            render_process_host->GetBrowserContext()) == this) {
-      render_process_host->Send(
-          new ViewMsg_SetZoomLevelForCurrentURL(std::string(), host, level));
-    }
-  }
+  SendZoomLevelChange(std::string(), host, level);
+
   HostZoomMap::ZoomLevelChange change;
   change.mode = HostZoomMap::ZOOM_CHANGED_FOR_HOST;
   change.host = host;
@@ -179,16 +187,7 @@ void HostZoomMapImpl::SetZoomLevelForHostAndScheme(const std::string& scheme,
     scheme_host_zoom_levels_[scheme][host] = level;
   }
 
-  // Notify renderers from this browser context.
-  for (RenderProcessHost::iterator i(RenderProcessHost::AllHostsIterator());
-       !i.IsAtEnd(); i.Advance()) {
-    RenderProcessHost* render_process_host = i.GetCurrentValue();
-    if (HostZoomMap::GetForBrowserContext(
-            render_process_host->GetBrowserContext()) == this) {
-      render_process_host->Send(
-          new ViewMsg_SetZoomLevelForCurrentURL(scheme, host, level));
-    }
-  }
+  SendZoomLevelChange(scheme, host, level);
 
   HostZoomMap::ZoomLevelChange change;
   change.mode = HostZoomMap::ZOOM_CHANGED_FOR_SCHEME_AND_HOST;
@@ -238,8 +237,12 @@ void HostZoomMapImpl::SetZoomLevelForWebContents(
   int render_process_id = web_contents_impl.GetRenderProcessHost()->GetID();
   int render_view_id = web_contents_impl.GetRenderViewHost()->GetRoutingID();
   if (UsesTemporaryZoomLevel(render_process_id, render_view_id)) {
-
-    SetTemporaryZoomLevel(render_process_id, render_view_id, level);
+    SetTemporaryZoomLevel(render_process_id,
+                          render_view_id,
+                          net::GetHostOrSpecFromURL(
+                              web_contents_impl.GetLastCommittedURL()),
+                          level,
+                          true);
   } else {
     SetZoomLevelForHost(
         net::GetHostOrSpecFromURL(web_contents_impl.GetLastCommittedURL()),
@@ -252,7 +255,7 @@ void HostZoomMapImpl::SetZoomLevelForView(int render_process_id,
                                           double level,
                                           const std::string& host) {
   if (UsesTemporaryZoomLevel(render_process_id, render_view_id))
-    SetTemporaryZoomLevel(render_process_id, render_view_id, level);
+    SetTemporaryZoomLevel(render_process_id, render_view_id, host, level, true);
   else
     SetZoomLevelForHost(host, level);
 }
@@ -302,7 +305,9 @@ double HostZoomMapImpl::GetTemporaryZoomLevel(int render_process_id,
 
 void HostZoomMapImpl::SetTemporaryZoomLevel(int render_process_id,
                                             int render_view_id,
-                                            double level) {
+                                            const std::string& host,

[Fady Samuel, 2014/06/09 15:43:21]

This is really weird and inconsistent with the expectations of the API. Why do
we need to pass in a host. From an API level, "temporary zoom" translates into
per-renderer zoom. Why does the host matter? Can we extract the current host
from some other place?

From the chrome code, it looks like we're extracting the host on the chrome side
via:

  content::NavigationEntry* entry =
      web_contents()->GetController().GetLastCommittedEntry();
  std::string host =
      net::GetHostOrSpecFromURL(entry ? entry->GetURL() : GURL::EmptyGURL());

This can be done here instead, simplifying the API we need to expose to
something that better matches the expectations of a content embedder developer.

[wjmaclean, 2014/06/09 17:23:29]

Sure, we can do that.

I added it primarily so it could be included in the ZoomLevelChange event, and
on the supposition that the caller likely already had the information handy.

[wjmaclean, 2014/06/10 13:20:09]

Done.

+                                            double level,
+                                            bool send_level_to_view) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   {
@@ -311,23 +316,23 @@ void HostZoomMapImpl::SetTemporaryZoomLevel(int render_process_id,
     for (i = 0; i < temporary_zoom_levels_.size(); ++i) {
       if (temporary_zoom_levels_[i].render_process_id == render_process_id &&
           temporary_zoom_levels_[i].render_view_id == render_view_id) {
-        if (level) {
-          temporary_zoom_levels_[i].zoom_level = level;
-        } else {
-          temporary_zoom_levels_.erase(temporary_zoom_levels_.begin() + i);
-        }
+        temporary_zoom_levels_[i].zoom_level = level;
         break;
       }
     }
 
-    if (level && i == temporary_zoom_levels_.size()) {
+    if (i == temporary_zoom_levels_.size()) {
       TemporaryZoomLevel temp(render_process_id, render_view_id, level);
       temporary_zoom_levels_.push_back(temp);
     }
   }
 
+  if (send_level_to_view)
+    SendZoomLevelChange(render_process_id, render_view_id, level);
+
   HostZoomMap::ZoomLevelChange change;
   change.mode = HostZoomMap::ZOOM_CHANGED_TEMPORARY_ZOOM;
+  change.host = host;
   change.zoom_level = level;
 
   zoom_level_changed_callbacks_.Notify(change);
@@ -338,18 +343,10 @@ void HostZoomMapImpl::Observe(int type,
                               const NotificationDetails& details) {
   switch (type) {
     case NOTIFICATION_RENDER_VIEW_HOST_WILL_CLOSE_RENDER_VIEW: {
-      base::AutoLock auto_lock(lock_);
       int render_view_id = Source<RenderViewHost>(source)->GetRoutingID();
       int render_process_id =
           Source<RenderViewHost>(source)->GetProcess()->GetID();
-
-      for (size_t i = 0; i < temporary_zoom_levels_.size(); ++i) {
-        if (temporary_zoom_levels_[i].render_process_id == render_process_id &&
-            temporary_zoom_levels_[i].render_view_id == render_view_id) {
-          temporary_zoom_levels_.erase(temporary_zoom_levels_.begin() + i);
-          break;
-        }
-      }
+      EraseTemporaryZoomLevel(render_process_id, render_view_id);
       break;
     }
     default:
@@ -357,6 +354,49 @@ void HostZoomMapImpl::Observe(int type,
   }
 }
 
+void HostZoomMapImpl::EraseTemporaryZoomLevel(int render_process_id,
+                                              int render_view_id) {
+  base::AutoLock auto_lock(lock_);
+  for (size_t i = 0; i < temporary_zoom_levels_.size(); ++i) {
+    if (temporary_zoom_levels_[i].render_process_id == render_process_id &&
+        temporary_zoom_levels_[i].render_view_id == render_view_id) {
+      // TODO(wjmaclean) Do we need to lookup the appropriate per-origin
+      // zoom level (if any) and send it to the render view?
+      temporary_zoom_levels_.erase(temporary_zoom_levels_.begin() + i);
+      break;
+    }
+  }
+}
+
+void HostZoomMapImpl::SendZoomLevelChange(int render_process_id,
+                                          int render_view_id,
+                                          double level) {
+  RenderViewHost* host =
+      RenderViewHost::FromID(render_process_id, render_view_id);
+  DCHECK(host);
+  host->Send(new ViewMsg_SetZoomLevelForView(render_view_id, level));
+}
+
+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) {
+      int render_process_id = render_process_host->GetID();
+      std::set<int> exceptions;
+      for (size_t i = 0; i != temporary_zoom_levels_.size(); ++i) {
+        if (temporary_zoom_levels_[i].render_process_id == render_process_id)
+          exceptions.insert(temporary_zoom_levels_[i].render_view_id);
+      }
+      render_process_host->Send(new ViewMsg_SetZoomLevelForCurrentURL(
+          scheme, host, level, exceptions));
+    }
+  }
+}
+
 HostZoomMapImpl::~HostZoomMapImpl() {
 }