Remove ViewMsg_SetZoomLevel

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 {
 
 HostZoomMap* HostZoomMap::GetForBrowserContext(BrowserContext* context) {
   HostZoomMapImpl* rv = static_cast<HostZoomMapImpl*>(
       context->GetUserData(kHostZoomMapKeyName));
   if (!rv) {
     rv = new HostZoomMapImpl();
     context->SetUserData(kHostZoomMapKeyName, rv);
   }
   return rv;
 }
 
+double HostZoomMap::GetZoomLevel(const WebContents* web_contents) {
+  HostZoomMapImpl* host_zoom_map = static_cast<HostZoomMapImpl*>(
+      HostZoomMap::GetForBrowserContext(web_contents->GetBrowserContext()));
+  return host_zoom_map->GetZoomLevelForWebContents(*web_contents);
+}
+
+void HostZoomMap::SetZoomLevel(const WebContents* web_contents, double level) {
+  HostZoomMapImpl* host_zoom_map = static_cast<HostZoomMapImpl*>(
+      HostZoomMap::GetForBrowserContext(web_contents->GetBrowserContext()));
+  host_zoom_map->SetZoomLevelForWebContents(*web_contents, level);
+}
+
 HostZoomMapImpl::HostZoomMapImpl()
     : default_zoom_level_(0.0) {
   registrar_.Add(
       this, NOTIFICATION_RENDER_VIEW_HOST_WILL_CLOSE_RENDER_VIEW,
       NotificationService::AllSources());
 }
 
 void HostZoomMapImpl::CopyFrom(HostZoomMap* copy_interface) {
   // This can only be called on the UI thread to avoid deadlocks, otherwise
   //   UI: a.CopyFrom(b);
   //   IO: b.CopyFrom(a);
   // can deadlock.
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   HostZoomMapImpl* copy = static_cast<HostZoomMapImpl*>(copy_interface);
   base::AutoLock auto_lock(lock_);
   base::AutoLock copy_auto_lock(copy->lock_);
   host_zoom_levels_.
       insert(copy->host_zoom_levels_.begin(), copy->host_zoom_levels_.end());
   for (SchemeHostZoomLevels::const_iterator i(copy->
            scheme_host_zoom_levels_.begin());
        i != copy->scheme_host_zoom_levels_.end(); ++i) {
     scheme_host_zoom_levels_[i->first] = HostZoomLevels();
     scheme_host_zoom_levels_[i->first].
         insert(i->second.begin(), i->second.end());
   }
   default_zoom_level_ = copy->default_zoom_level_;
 }
 
+double HostZoomMapImpl::GetZoomLevelForWebContents(
+    const WebContents& web_contents) const {
+  const WebContentsImpl& web_contents_impl =
+      static_cast<const WebContentsImpl&>(web_contents);
+  int render_process_id = web_contents_impl.GetRenderProcessHost()->GetID();
+  int routing_id = web_contents_impl.GetRenderViewHost()->GetRoutingID();
+
+  if (UsesTemporaryZoomLevel(render_process_id, routing_id)) {
+    return GetTemporaryZoomLevel(render_process_id, routing_id);
+  } else {
+    GURL url;
+    NavigationEntry* entry =
+        web_contents_impl.GetController().GetLastCommittedEntry();
+    // Since zoom map is updated using rewritten URL, use rewritten URL to get
+    // the zoom level.
+    url = entry ? entry->GetURL() : GURL::EmptyGURL();
+    return GetZoomLevelForHostAndScheme(url.scheme(),
+                                        net::GetHostOrSpecFromURL(url));
+  }
+}
+
 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;
 }
 
 double HostZoomMapImpl::GetZoomLevelForHostAndScheme(
     const std::string& scheme,
     const std::string& host) const {
   {
@@ skipping 38 matching lines @@
                                   scheme,    // scheme
                                   j->second  // zoom level
         };
         result.push_back(change);
       }
     }
   }
   return result;
 }
 
+void HostZoomMapImpl::SetZoomLevelForWebContents(
+    const WebContents& web_contents,
+    double level) {
+  const WebContentsImpl& web_contents_impl =
+      static_cast<const WebContentsImpl&>(web_contents);
+  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);
+  } 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);
+  else
+    SetZoomLevelForHost(host, level);
+}
+
 void HostZoomMapImpl::SetZoomLevelForHost(const std::string& host,
                                           double level) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   {
     base::AutoLock auto_lock(lock_);
 
     if (ZoomValuesEqual(level, default_zoom_level_))
       host_zoom_levels_.erase(host);
     else
@@ skipping 54 matching lines @@
 void HostZoomMapImpl::SetDefaultZoomLevel(double level) {
   default_zoom_level_ = level;
 }
 
 scoped_ptr<HostZoomMap::Subscription>
 HostZoomMapImpl::AddZoomLevelChangedCallback(
     const ZoomLevelChangedCallback& callback) {
   return zoom_level_changed_callbacks_.Add(callback);
 }
 
+void HostZoomMapImpl::SetUsesTemporaryZoomLevel(
+    int render_process_id,
+    int render_view_id,
+    bool uses_temporary_zoom_settings) {
+  base::AutoLock auto_lock(lock_);
+  TemporaryZoomLevel zoom_level(
+      render_process_id, render_view_id, default_zoom_level_);
+  TemporaryZoomLevelList::iterator it = find(
+      temporary_zoom_levels_.begin(), temporary_zoom_levels_.end(), zoom_level);
+  if (uses_temporary_zoom_settings) {
+    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);
+  }
+}
+
+bool HostZoomMapImpl::UsesTemporaryZoomLevel(int render_process_id,
+                                             int render_view_id) const {
+  base::AutoLock auto_lock(lock_);
+  TemporaryZoomLevel zoom_level(render_process_id, render_view_id);
+  TemporaryZoomLevelList::const_iterator it = find(
+      temporary_zoom_levels_.begin(), temporary_zoom_levels_.end(), zoom_level);
+  return it != temporary_zoom_levels_.end();
+}
+
 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;
     }
   }
   return 0;
@@ skipping 13 matching lines @@
         if (level) {
           temporary_zoom_levels_[i].zoom_level = level;
         } else {
           temporary_zoom_levels_.erase(temporary_zoom_levels_.begin() + i);
         }
         break;
       }
     }
 
     if (level && i == temporary_zoom_levels_.size()) {
-      TemporaryZoomLevel temp;
-      temp.render_process_id = render_process_id;
-      temp.render_view_id = render_view_id;
-      temp.zoom_level = level;
+      TemporaryZoomLevel temp(render_process_id, render_view_id, level);
       temporary_zoom_levels_.push_back(temp);
     }
   }
 
   HostZoomMap::ZoomLevelChange change;
   change.mode = HostZoomMap::ZOOM_CHANGED_TEMPORARY_ZOOM;
   change.zoom_level = level;
 
   zoom_level_changed_callbacks_.Notify(change);
 }
@@ skipping 19 matching lines @@
     }
     default:
       NOTREACHED() << "Unexpected preference observed.";
   }
 }
 
 HostZoomMapImpl::~HostZoomMapImpl() {
 }
 
 }  // namespace content