Zoom Extension API (content changes)

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"
@@ skipping 69 matching lines @@
   }
   default_zoom_level_ = copy->default_zoom_level_;
 }
 
 double HostZoomMapImpl::GetZoomLevelForHost(const std::string& host) const {
   base::AutoLock auto_lock(lock_);
   HostZoomLevels::const_iterator i(host_zoom_levels_.find(host));
   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 {
   {
     base::AutoLock auto_lock(lock_);
     SchemeHostZoomLevels::const_iterator scheme_iterator(
         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())
@@ skipping 45 matching lines @@
 
   {
     base::AutoLock auto_lock(lock_);
 
     if (ZoomValuesEqual(level, default_zoom_level_))
       host_zoom_levels_.erase(host);
     else
       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;
   change.zoom_level = level;
 
   zoom_level_changed_callbacks_.Notify(change);
 }
 
 void HostZoomMapImpl::SetZoomLevelForHostAndScheme(const std::string& scheme,
                                                    const std::string& host,
                                                    double level) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   {
     base::AutoLock auto_lock(lock_);
     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;
   change.host = host;
   change.scheme = scheme;
   change.zoom_level = level;
 
   zoom_level_changed_callbacks_.Notify(change);
 }
 
@@ skipping 29 matching lines @@
   return GetZoomLevelForHostAndScheme(url.scheme(),
                                       net::GetHostOrSpecFromURL(url));
 }
 
 void HostZoomMapImpl::SetZoomLevelForWebContents(
     const WebContentsImpl& web_contents_impl,
     double level) {
   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()),
         level);
   }
 }
 
 void HostZoomMapImpl::SetZoomLevelForView(int render_process_id,
                                           int render_view_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);
 }
 
 bool HostZoomMapImpl::UsesTemporaryZoomLevel(int render_process_id,
                                              int render_view_id) const {
   TemporaryZoomLevel zoom_level(render_process_id, render_view_id);
 
   base::AutoLock auto_lock(lock_);
   TemporaryZoomLevels::const_iterator it = std::find(
@@ skipping 29 matching lines @@
         temporary_zoom_levels_[i].render_view_id == render_view_id) {
       return temporary_zoom_levels_[i].zoom_level;
     }
   }
 
   return 0;
 }
 
 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));
 
   {
     base::AutoLock auto_lock(lock_);
     size_t i;
     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);
 }
 
 void HostZoomMapImpl::Observe(int type,
                               const NotificationSource& source,
                               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:
       NOTREACHED() << "Unexpected preference observed.";
   }
 }
 
+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() {
 }
 
 HostZoomMapImpl::TemporaryZoomLevel::TemporaryZoomLevel(int process_id,
                                                         int view_id,
                                                         double level)
     : render_process_id(process_id),
       render_view_id(view_id),
       zoom_level(level) {
 }
 
 HostZoomMapImpl::TemporaryZoomLevel::TemporaryZoomLevel(int process_id,
                                                         int view_id)
     : render_process_id(process_id),
       render_view_id(view_id),
       zoom_level(0.0) {
 }
 
 bool HostZoomMapImpl::TemporaryZoomLevel::operator==(
     const TemporaryZoomLevel& other) const {
   return other.render_process_id == render_process_id &&
          other.render_view_id == render_view_id;
 }
 
 }  // namespace content