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::HasZoomLevel(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 31 matching lines @@
     url = entry->GetURL();
   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();
+  // Get the url from the navigation controller directly, as calling
+  // WebContentsImpl::GetLastCommittedURL() may give us a virtual url that
+  // is different than what the render view is using. If the two don't match,
+  // the attempt to set the zoom will fail.
+  NavigationEntry* entry =

[Fady Samuel, 2014/06/10 20:05:13]

It looks like this is only used in the else clause. Move this down to the else
clause.

[wjmaclean, 2014/06/10 20:18:54]

Done.

+      web_contents_impl.GetController().GetLastCommittedEntry();
+  DCHECK(entry);
+  GURL url = entry->GetURL();
   if (UsesTemporaryZoomLevel(render_process_id, render_view_id)) {
-    SetTemporaryZoomLevel(render_process_id, render_view_id, level);
+    SetTemporaryZoomLevel(render_process_id,
+                          render_view_id,
+                          level);
+    SendTemporaryZoomLevelChange(render_process_id, render_view_id);
   } else {
-    // Get the url from the navigation controller directly, as calling
-    // WebContentsImpl::GetLastCommittedURL() may give us a virtual url that
-    // is different than what the render view is using. If the two don't match,
-    // the attempt to set the zoom will fail.
-    GURL url;
-    NavigationEntry* entry =
-        web_contents_impl.GetController().GetLastCommittedEntry();
-    DCHECK(entry);
-    url = entry->GetURL();
     SetZoomLevelForHost(net::GetHostOrSpecFromURL(url), 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))
+  if (UsesTemporaryZoomLevel(render_process_id, render_view_id)) {
     SetTemporaryZoomLevel(render_process_id, render_view_id, level);
-  else
+    SendTemporaryZoomLevelChange(render_process_id, render_view_id);

[Fady Samuel, 2014/06/10 20:05:13]

This looks like the only call site for SetZoomLevelForView:

https://code.google.com/p/chromium/codesearch#chromium/src/content/browser/re...

+  } 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(
       temporary_zoom_levels_.begin(), temporary_zoom_levels_.end(), zoom_level);
   return it != temporary_zoom_levels_.end();
 }
 
 void HostZoomMapImpl::SetUsesTemporaryZoomLevel(

[Fady Samuel, 2014/06/10 20:05:13]

Do we need this method? It seems unnecessary if we use SetTemporaryZoomLevel and
ClearTemporaryZoomLevel.

[wjmaclean, 2014/06/12 17:40:09]

Done.

     int render_process_id,
     int render_view_id,
     bool uses_temporary_zoom_level) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   TemporaryZoomLevel zoom_level(
       render_process_id, render_view_id, default_zoom_level_);
 
   base::AutoLock auto_lock(lock_);
   TemporaryZoomLevels::iterator it = std::find(
@@ skipping 12 matching lines @@
   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) {
       return temporary_zoom_levels_[i].zoom_level;
     }
   }
 
   return 0;
 }
 
+namespace {
+
+std::string GetHostFromProcessView(int render_process_id, int render_view_id) {

[Fady Samuel, 2014/06/10 20:05:13]

DCHECK to make sure this is only called on the UI thread.

[wjmaclean, 2014/06/12 17:40:09]

Done.

+  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);
+  DCHECK(web_contents);
+
+  NavigationEntry* entry =
+      web_contents->GetController().GetLastCommittedEntry();
+  if (!entry)
+    return std::string();
+
+  return net::GetHostOrSpecFromURL(entry->GetURL());
+}
+
+}  // namespace
+
 void HostZoomMapImpl::SetTemporaryZoomLevel(int render_process_id,
                                             int render_view_id,
                                             double level) {
   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;

[Fady Samuel, 2014/06/10 20:05:13]

This becomes trivial once it's a map.

[wjmaclean, 2014/06/10 20:18:54]

Done.

         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);
+      RenderViewHost* host =
+          RenderViewHost::FromID(render_process_id, render_view_id);
+      DCHECK(host);
+      host->Send(new ViewMsg_SetUsesTemporaryZoomLevel(render_view_id, true));

[Fady Samuel, 2014/06/10 20:05:13]

ViewMsg_SetTemporaryZoomLevel(render_view_id, true, level);

[wjmaclean, 2014/06/10 20:18:54]

But this will force us to send a level value for manual mode, where it is
irrelevant. I don't think that makes sense.

[wjmaclean, 2014/06/12 17:40:09]

Now that content will have no knowledge of manual mode, we'll merge these.

     }
   }
 
   HostZoomMap::ZoomLevelChange change;
   change.mode = HostZoomMap::ZOOM_CHANGED_TEMPORARY_ZOOM;
+  change.host = GetHostFromProcessView(render_process_id, render_view_id);
   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;
-        }
-      }
+      ClearTemporaryZoomLevel(render_process_id, render_view_id);
       break;
     }
     default:
       NOTREACHED() << "Unexpected preference observed.";
   }
 }
 
+void HostZoomMapImpl::ClearTemporaryZoomLevel(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) {

[Fady Samuel, 2014/06/10 20:05:13]

With the map, the above becomes trivial.

[wjmaclean, 2014/06/10 20:18:54]

Done.

+      // 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);
+      RenderViewHost* host =
+          RenderViewHost::FromID(render_process_id, render_view_id);
+      DCHECK(host);
+      host->Send(new ViewMsg_SetUsesTemporaryZoomLevel(render_view_id, false));

[Fady Samuel, 2014/06/10 20:05:13]

ViewMsg_SetTemporaryZoomLevel(render_view_id, false, /* grab the host zoom level
here to reset behavior */);

+      break;
+    }
+  }
+}
+
+void HostZoomMapImpl::SendTemporaryZoomLevelChange(int render_process_id,

[Fady Samuel, 2014/06/10 20:05:13]

I wish we didn't have to expose this publicly. Ideally manual would be another
bit we set in the renderer so that the behavior sticks for the lifetime of the
renderer. Ignore this comment for now, but we can get John's feedback here.

[wjmaclean, 2014/06/10 20:18:54]

Done.

+                                                   int render_view_id) const {
+  double level = 0.0;
+  bool found = false;
+  {
+    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) {
+        level = temporary_zoom_levels_[i].zoom_level;
+        found = true;
+        break;
+      }
+    }
+  }

[Fady Samuel, 2014/06/10 20:05:13]

With the map, the above becomes trivial.

[wjmaclean, 2014/06/10 20:18:54]

Done.

+  if (!found)
+    return;
+
+  RenderViewHost* host =
+      RenderViewHost::FromID(render_process_id, render_view_id);
+  DCHECK(host);
+  host->Send(new ViewMsg_SetZoomLevelForView(render_view_id, level));

[Fady Samuel, 2014/06/10 20:05:13]

ViewMsg_SetTemporaryZoomLevel(render_view_id, true, level);

[wjmaclean, 2014/06/10 20:18:54]

See my previous comment about combining these.

+}
+
+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) {
+      render_process_host->Send(
+          new ViewMsg_SetZoomLevelForCurrentURL(scheme, host, level));
+    }
+  }
+}
+
 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