Fix page zoom to be frame-centric for out-of-process frames.

content/renderer/render_thread_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/renderer/render_thread_impl.h"
 
 #include <algorithm>
 #include <limits>
 #include <map>
 #include <utility>
@@ skipping 240 matching lines @@
 
  private:
   // WebThreadImplForWorkerScheduler:
   scoped_ptr<scheduler::WorkerScheduler> CreateWorkerScheduler() override {
     return make_scoped_ptr(new scheduler::CompositorWorkerScheduler(thread()));
   }
 
   DISALLOW_COPY_AND_ASSIGN(WebThreadForCompositor);
 };
 
-class RenderViewZoomer : public RenderViewVisitor {
- public:
-  RenderViewZoomer(const std::string& scheme,
-                   const std::string& host,
-                   double zoom_level) : scheme_(scheme),
-                                        host_(host),
-                                        zoom_level_(zoom_level) {
-  }
-
-  bool Visit(RenderView* render_view) override {
-    WebView* webview = render_view->GetWebView();
-    RenderViewImpl* render_view_impl =
-        static_cast<RenderViewImpl*>(render_view);
-    // Remote frames don't host documents.
-    // TODO(wjmaclean) Although it seems likely that a frame without a
-    // document can safely early-out here, we should confirm this is truly
-    // the case. https://crbug.com/477007
-    if (webview->mainFrame()->isWebRemoteFrame())
-      return true;
-
-    WebDocument document = webview->mainFrame()->document();
-
-    // Don't set zoom level for full-page plugin since they don't use the same
-    // zoom settings.
-    if (document.isPluginDocument())
-      return true;
-    GURL url(document.url());
-    // Empty scheme works as wildcard that matches any scheme,
-    if ((net::GetHostOrSpecFromURL(url) == host_) &&
-        (scheme_.empty() || scheme_ == url.scheme()) &&
-        !render_view_impl->uses_temporary_zoom_level()) {
-      webview->hidePopups();
-      render_view_impl->SetZoomLevel(zoom_level_);
-    }
-    return true;
-  }
-
- private:
-  const std::string scheme_;
-  const std::string host_;
-  const double zoom_level_;
-
-  DISALLOW_COPY_AND_ASSIGN(RenderViewZoomer);
-};
-
 void* CreateHistogram(
     const char *name, int min, int max, size_t buckets) {
   if (min <= 0)
     min = 1;
   std::string histogram_name;
   RenderThreadImpl* render_thread_impl = RenderThreadImpl::current();
   if (render_thread_impl) {  // Can be null in tests.
     histogram_name = render_thread_impl->
         histogram_customizer()->ConvertToCustomHistogramName(name);
   } else {
@@ skipping 1423 matching lines @@
   if (appcache_dispatcher_->OnMessageReceived(msg) ||
       dom_storage_dispatcher_->OnMessageReceived(msg) ||
       embedded_worker_dispatcher_->OnMessageReceived(msg)) {
     return true;
   }
 
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP(RenderThreadImpl, msg)
     IPC_MESSAGE_HANDLER(FrameMsg_NewFrame, OnCreateNewFrame)
     IPC_MESSAGE_HANDLER(FrameMsg_NewFrameProxy, OnCreateNewFrameProxy)
-    IPC_MESSAGE_HANDLER(ViewMsg_SetZoomLevelForCurrentURL,
-                        OnSetZoomLevelForCurrentURL)
     // TODO(port): removed from render_messages_internal.h;
     // is there a new non-windows message I should add here?
     IPC_MESSAGE_HANDLER(ViewMsg_New, OnCreateNewView)
     IPC_MESSAGE_HANDLER(ViewMsg_NetworkConnectionChanged,
                         OnNetworkConnectionChanged)
     IPC_MESSAGE_HANDLER(WorkerProcessMsg_CreateWorker, OnCreateNewSharedWorker)
     IPC_MESSAGE_HANDLER(ViewMsg_TimezoneChange, OnUpdateTimezone)
 #if defined(OS_ANDROID)
     IPC_MESSAGE_HANDLER(ViewMsg_SetWebKitSharedTimersSuspended,
                         OnSetWebKitSharedTimersSuspended)
@@ skipping 41 matching lines @@
                                 base::IntToString(render_view_routing_id));
   base::debug::SetCrashKeyValue("newproxy_opener_id",
                                 base::IntToString(opener_routing_id));
   base::debug::SetCrashKeyValue("newproxy_parent_id",
                                 base::IntToString(parent_routing_id));
   RenderFrameProxy::CreateFrameProxy(routing_id, render_view_routing_id,
                                      opener_routing_id, parent_routing_id,
                                      replicated_state);
 }
 
-void RenderThreadImpl::OnSetZoomLevelForCurrentURL(const std::string& scheme,
-                                                   const std::string& host,
-                                                   double zoom_level) {
-  RenderViewZoomer zoomer(scheme, host, zoom_level);
-  RenderView::ForEach(&zoomer);
-}
-
 void RenderThreadImpl::OnCreateNewView(const ViewMsg_New_Params& params) {
   CompositorDependencies* compositor_deps = this;
   // When bringing in render_view, also bring in webkit's glue and jsbindings.
   RenderViewImpl::Create(compositor_deps, params, false);
 }
 
 gpu::GpuChannelHost* RenderThreadImpl::EstablishGpuChannelSync(
     CauseForGpuLaunch cause_for_gpu_launch) {
   TRACE_EVENT0("gpu", "RenderThreadImpl::EstablishGpuChannelSync");
 
@@ skipping 316 matching lines @@
 }
 
 void RenderThreadImpl::PendingRenderFrameConnect::OnConnectionError() {
   size_t erased =
       RenderThreadImpl::current()->pending_render_frame_connects_.erase(
           routing_id_);
   DCHECK_EQ(1u, erased);
 }
 
 }  // namespace content