Changes to content/ to facilitate new zoom extension API

content/browser/web_contents/web_contents_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/web_contents/web_contents_impl.h"
 
 #include <utility>
 
 #include "base/command_line.h"
 #include "base/debug/trace_event.h"
@@ skipping 320 matching lines @@
       last_active_time_(base::TimeTicks::Now()),
       closed_by_user_gesture_(false),
       minimum_zoom_percent_(static_cast<int>(kMinimumZoomFactor * 100)),
       maximum_zoom_percent_(static_cast<int>(kMaximumZoomFactor * 100)),
       temporary_zoom_settings_(false),
       totalPinchGestureAmount_(0),
       currentPinchZoomStepDelta_(0),
       color_chooser_identifier_(0),
       render_view_message_source_(NULL),
       fullscreen_widget_routing_id_(MSG_ROUTING_NONE),
-      is_subframe_(false) {
+      is_subframe_(false),
+      current_zoom_mode_(kZoomModeDefault),
+      current_zoom_id_(1) {
   for (size_t i = 0; i < g_created_callbacks.Get().size(); i++)
     g_created_callbacks.Get().at(i).Run(this);
   frame_tree_.SetFrameRemoveListener(
       base::Bind(&WebContentsImpl::OnFrameRemoved,
                  base::Unretained(this)));
 }
 
 WebContentsImpl::~WebContentsImpl() {
   is_being_destroyed_ = true;
 
@@ skipping 1627 matching lines @@
 }
 
 void WebContentsImpl::SetClosedByUserGesture(bool value) {
   closed_by_user_gesture_ = value;
 }
 
 bool WebContentsImpl::GetClosedByUserGesture() const {
   return closed_by_user_gesture_;
 }
 
+content::ZoomMode WebContentsImpl::GetZoomMode() const {
+  return current_zoom_mode_;
+}
+
 double WebContentsImpl::GetZoomLevel() const {
+  if (current_zoom_mode_ == kZoomModeDisabled)
+    return 0;
+
   HostZoomMapImpl* zoom_map = static_cast<HostZoomMapImpl*>(
       HostZoomMap::GetForBrowserContext(GetBrowserContext()));
   if (!zoom_map)
     return 0;
 
   double zoom_level;
   if (temporary_zoom_settings_) {
     zoom_level = zoom_map->GetTemporaryZoomLevel(
         GetRenderProcessHost()->GetID(), GetRenderViewHost()->GetRoutingID());
   } else {
@@ skipping 79 matching lines @@
   int id = StartDownload(GetMainFrame(), url, is_favicon, max_bitmap_size);
   image_download_map_[id] = callback;
   return id;
 }
 
 bool WebContentsImpl::IsSubframe() const {
   return is_subframe_;
 }
 
 void WebContentsImpl::SetZoomLevel(double level) {
-  Send(new ViewMsg_SetZoomLevel(GetRoutingID(), level));
+  if (current_zoom_mode_ == kZoomModeDisabled)
+    return;
+
+  Send(new ViewMsg_SetZoomLevel(GetRoutingID(), current_zoom_id_++, level,
+                                current_zoom_mode_));
   BrowserPluginEmbedder* embedder = GetBrowserPluginEmbedder();
   if (embedder)
     embedder->SetZoomLevel(level);
+
+  // Notify observers about the initiated zoom change.
+  FOR_EACH_OBSERVER(WebContentsObserver, observers_,
+                    DidSetZoomLevel(GetZoomLevel(), level, current_zoom_mode_));
+}
+
+void WebContentsImpl::SetZoomLevel(double level,
+                                   const base::Callback<void(void)>& callback) {
+  if (current_zoom_mode_ == kZoomModeDisabled)
+    return;
+
+  // Add the callback to HostZoomMap so that it can be called after the zoom
+  // change has completed.
+  HostZoomMapImpl* zoom_map = static_cast<HostZoomMapImpl*>(
+      HostZoomMap::GetForBrowserContext(GetBrowserContext()));
+  DCHECK(zoom_map);
+  zoom_map->AddZoomCallback(current_zoom_id_, callback);
+  SetZoomLevel(level);
+}
+
+void WebContentsImpl::SetZoomMode(ZoomMode mode) {
+  if (mode == current_zoom_mode_)
+    return;
+
+  double original_zoom_level = GetZoomLevel();
+  switch (mode) {
+    case kZoomModeDefault: {
+      Send(new ViewMsg_SetZoomLevel(GetRoutingID(), 0, original_zoom_level,
+                                    kZoomModeDefault));
+      // Remove per-tab zoom data for this tab.
+      HostZoomMapImpl* zoom_map = static_cast<HostZoomMapImpl*>(
+          HostZoomMap::GetForBrowserContext(GetBrowserContext()));
+      DCHECK(zoom_map);
+      int render_process_id = GetRenderProcessHost()->GetID();
+      int render_view_id = GetRenderViewHost()->GetRoutingID();
+      zoom_map->EraseTemporaryZoomLevel(render_process_id, render_view_id);
+      break;
+    }
+    case kZoomModeIsolated: {
+      // Unless the zoom mode was |kZoomModeDisabled| before this call, the page
+      // needs an initial isolated zoom back to the same level it was at in the
+      // other mode.
+      if (current_zoom_mode_ != kZoomModeDisabled) {
+        Send(new ViewMsg_SetZoomLevel(GetRoutingID(), 0, original_zoom_level,
+                                      kZoomModeIsolated));
+      }
+      break;
+    }
+    case kZoomModeManual: {
+      // Unless the zoom mode was |kZoomModeDisabled| before this call, the page
+      // needs to be resized to the default zoom before calling SetZoomLevel()
+      // so that the page can be resized manually to the same zoom as before.
+      if (current_zoom_mode_ != kZoomModeDisabled) {
+        Send(new ViewMsg_SetZoomLevel(GetRoutingID(), 0, 0, kZoomModeIsolated));
+        current_zoom_mode_ = mode;
+        SetZoomLevel(original_zoom_level);
+      }
+      break;
+    }
+    case kZoomModeDisabled: {
+      // The page needs to be zoomed back to default before disabling the zoom
+      // (unless it was just in |kZoomModeManual| mode, in which case this is
+      // already done).
+      if (current_zoom_mode_ != kZoomModeManual) {
+        Send(new ViewMsg_SetZoomLevel(GetRoutingID(), 0, 0, kZoomModeIsolated));
+      }
+      break;
+    }
+  }
+
+  current_zoom_mode_ = mode;
+  temporary_zoom_settings_ = mode != kZoomModeDefault;
 }
 
 void WebContentsImpl::Find(int request_id,
                            const base::string16& search_text,
                            const blink::WebFindOptions& options) {
   Send(new ViewMsg_Find(GetRoutingID(), request_id, search_text, options));
 }
 
 void WebContentsImpl::StopFinding(StopFindAction action) {
   Send(new ViewMsg_StopFinding(GetRoutingID(), action));
@@ skipping 316 matching lines @@
 void WebContentsImpl::OnGoToEntryAtOffset(int offset) {
   if (!delegate_ || delegate_->OnGoToEntryOffset(offset))
     controller_.GoToOffset(offset);
 }
 
 void WebContentsImpl::OnUpdateZoomLimits(int minimum_percent,
                                          int maximum_percent,
                                          bool remember) {
   minimum_zoom_percent_ = minimum_percent;
   maximum_zoom_percent_ = maximum_percent;
-  temporary_zoom_settings_ = !remember;
+  temporary_zoom_settings_ = !remember ||
+      current_zoom_mode_ != kZoomModeDefault;
 }
 
 void WebContentsImpl::OnEnumerateDirectory(int request_id,
                                            const base::FilePath& path) {
   if (!delegate_)
     return;
 
   ChildProcessSecurityPolicyImpl* policy =
       ChildProcessSecurityPolicyImpl::GetInstance();
   if (policy->CanReadFile(GetRenderProcessHost()->GetID(), path))
@@ skipping 379 matching lines @@
 
   notify_disconnection_ = false;
   NotificationService::current()->Notify(
       NOTIFICATION_WEB_CONTENTS_DISCONNECTED,
       Source<WebContents>(this),
       NotificationService::NoDetails());
 }
 
 void WebContentsImpl::NotifyNavigationEntryCommitted(
     const LoadCommittedDetails& load_details) {
+  // The zoom mode resets on navigation to a different page.
+  if (load_details.is_navigation_to_different_page()) {
+    temporary_zoom_settings_ = false;
+    SetZoomMode(kZoomModeDefault);
+  }
+
   FOR_EACH_OBSERVER(
       WebContentsObserver, observers_, NavigationEntryCommitted(load_details));
 }
 
 bool WebContentsImpl::OnMessageReceived(RenderFrameHost* render_frame_host,
                                         const IPC::Message& message) {
   return OnMessageReceived(NULL, render_frame_host, message);
 }
 
 const GURL& WebContentsImpl::GetMainFrameLastCommittedURL() const {
@@ skipping 854 matching lines @@
 
 void WebContentsImpl::OnPreferredSizeChanged(const gfx::Size& old_size) {
   if (!delegate_)
     return;
   const gfx::Size new_size = GetPreferredSize();
   if (new_size != old_size)
     delegate_->UpdatePreferredSize(this, new_size);
 }
 
 }  // namespace content