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"
 #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/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;
 }
 
@@ skipping 40 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);

[palmer, 2014/06/13 17:47:01]

Empty scheme? Why? It seems like this should always be tied to a complete origin
(scheme, host, port).

[wjmaclean, 2014/06/13 20:05:22]

Filed bug to investigate: crbug.com/384486.

+
   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 62 matching lines @@
                                           double level,
                                           const std::string& host) {
   if (UsesTemporaryZoomLevel(render_process_id, render_view_id))
     SetTemporaryZoomLevel(render_process_id, render_view_id, level);
   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);
+  RenderViewKey key(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(
-    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(
-      temporary_zoom_levels_.begin(), temporary_zoom_levels_.end(), zoom_level);
-  if (uses_temporary_zoom_level) {
-    if (it == temporary_zoom_levels_.end())
-      temporary_zoom_levels_.push_back(zoom_level);
-  } else if (it != temporary_zoom_levels_.end()) {
-      temporary_zoom_levels_.erase(it);
-  }
+  return ContainsKey(temporary_zoom_levels_, key);
 }
 
 double HostZoomMapImpl::GetTemporaryZoomLevel(int render_process_id,
                                               int render_view_id) const {
   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) {
-      return temporary_zoom_levels_[i].zoom_level;
-    }
-  }
+  RenderViewKey key(render_process_id, render_view_id);
+  if (!ContainsKey(temporary_zoom_levels_, key))
+    return 0;
 
-  return 0;
+  return temporary_zoom_levels_.find(key)->second;
 }
 
 void HostZoomMapImpl::SetTemporaryZoomLevel(int render_process_id,
                                             int render_view_id,
                                             double level) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   {
+    RenderViewKey key(render_process_id, render_view_id);
     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);
-        }
-        break;
-      }
-    }
+    temporary_zoom_levels_[key] = level;
+  }
 
-    if (level && 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);
+  host->Send(new ViewMsg_SetZoomLevelForView(render_view_id, true, level));
 
   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_);
+    RenderViewKey key(render_process_id, render_view_id);
+    TemporaryZoomLevels::iterator it = temporary_zoom_levels_.find(key);
+    if (it == temporary_zoom_levels_.end())
+      return;
+    temporary_zoom_levels_.erase(it);
+  }
+  RenderViewHost* host =
+      RenderViewHost::FromID(render_process_id, render_view_id);
+  DCHECK(host);
+  // Send a new zoom level, host-specific if one exists.
+  host->Send(new ViewMsg_SetZoomLevelForView(
+      render_view_id,
+      false,
+      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) {
+      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