Make command-zero reset page scale in addition to zoom level

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 73 matching lines @@
 
 // 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::GetForWebContents(web_contents));
   return host_zoom_map->GetZoomLevelForWebContents(
       *static_cast<const WebContentsImpl*>(web_contents));
 }
 
+bool HostZoomMap::PageScaleFactorIsOne(const WebContents* web_contents) {
+  HostZoomMapImpl* host_zoom_map = static_cast<HostZoomMapImpl*>(
+      HostZoomMap::GetForWebContents(web_contents));
+  return host_zoom_map->PageScaleFactorIsOneForWebContents(
+      *static_cast<const WebContentsImpl*>(web_contents));
+}
+
 void HostZoomMap::SetZoomLevel(const WebContents* web_contents, double level) {
   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 =
@@ skipping 223 matching lines @@
 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);
   else
     SetZoomLevelForHost(host, level);
 }
 
+void HostZoomMapImpl::SetPageScaleFactorIsOneForView(int render_process_id,
+                                                     int render_view_id,
+                                                     bool is_one) {
+  {
+    base::AutoLock auto_lock(lock_);
+    view_page_scale_factors_are_one_[RenderViewKey(render_process_id,
+                                                   render_view_id)] = is_one;
+  }
+  HostZoomMap::ZoomLevelChange change;
+  change.mode = HostZoomMap::PAGE_SCALE_IS_ONE_CHANGED;
+  zoom_level_changed_callbacks_.Notify(change);
+}
+
+bool HostZoomMapImpl::PageScaleFactorIsOneForWebContents(
+    const WebContentsImpl& web_contents_impl) const {
+  if (!web_contents_impl.GetRenderProcessHost())
+    return true;
+  base::AutoLock auto_lock(lock_);
+  auto found = view_page_scale_factors_are_one_.find(
+      RenderViewKey(web_contents_impl.GetRenderProcessHost()->GetID(),
+                    web_contents_impl.GetRoutingID()));
+  if (found == view_page_scale_factors_are_one_.end())
+    return true;
+  return found->second;
+}
+
+void HostZoomMapImpl::ClearPageScaleFactorIsOneForView(int render_process_id,
+                                                       int render_view_id) {
+  base::AutoLock auto_lock(lock_);
+  view_page_scale_factors_are_one_.erase(
+      RenderViewKey(render_process_id, render_view_id));
+}
+
 bool HostZoomMapImpl::UsesTemporaryZoomLevel(int render_process_id,
                                              int render_view_id) const {
   RenderViewKey key(render_process_id, render_view_id);
 
   base::AutoLock auto_lock(lock_);
   return ContainsKey(temporary_zoom_levels_, key);
 }
 
 double HostZoomMapImpl::GetTemporaryZoomLevel(int render_process_id,
                                               int render_view_id) const {
@@ skipping 43 matching lines @@
 
 void HostZoomMapImpl::Observe(int type,
                               const NotificationSource& source,
                               const NotificationDetails& details) {
   switch (type) {
     case NOTIFICATION_RENDER_VIEW_HOST_WILL_CLOSE_RENDER_VIEW: {
       int render_view_id = Source<RenderViewHost>(source)->GetRoutingID();
       int render_process_id =
           Source<RenderViewHost>(source)->GetProcess()->GetID();
       ClearTemporaryZoomLevel(render_process_id, render_view_id);
+      ClearPageScaleFactorIsOneForView(render_process_id, render_view_id);
       break;
     }
     default:
       NOTREACHED() << "Unexpected preference observed.";
   }
 }
 
 void HostZoomMapImpl::ClearTemporaryZoomLevel(int render_process_id,
                                               int render_view_id) {
   {
@@ skipping 37 matching lines @@
   double error_page_zoom_level = GetZoomLevelForHost(host);
 
   SendZoomLevelChange(std::string(), host, error_page_zoom_level);
 }
 
 HostZoomMapImpl::~HostZoomMapImpl() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 }
 
 }  // namespace content