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;
+
+  ZoomChangeDetails zoom_change_details;
+  zoom_change_details.old_zoom_level = GetZoomLevel();
+  zoom_change_details.new_zoom_level = level;
+  zoom_change_details.zoom_mode = current_zoom_mode_;
+  NotificationService::current()->Notify(
+      content::NOTIFICATION_WEB_CONTENTS_ZOOM_CHANGE,
+      Source<WebContents>(this),
+      content::Details<ZoomChangeDetails>(
+          &zoom_change_details));
+
+  Send(new ViewMsg_SetZoomLevel(GetRoutingID(), current_zoom_id_++, level,
+                                current_zoom_mode_));
   BrowserPluginEmbedder* embedder = GetBrowserPluginEmbedder();
   if (embedder)
     embedder->SetZoomLevel(level);
 }
 
+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();
+
+  if (mode == kZoomModeDefault) {

[Fady Samuel, 2014/04/10 14:27:25]

I think a switch statement would be easier to read here.

[paulmeyer, 2014/04/10 15:11:49]

Done.

+    Send(new ViewMsg_SetZoomLevel(GetRoutingID(), 0, original_zoom_level,
+                                  kZoomModeDefault));
+    NotificationService::current()->Notify(
+        NOTIFICATION_WEB_CONTENTS_NO_TEMPORARY_ZOOM_LEVEL,
+        Source<WebContents>(this),
+        NotificationService::NoDetails());
+  } else if (mode == kZoomModeIsolated) {
+    if (current_zoom_mode_ != kZoomModeDisabled) {
+      Send(new ViewMsg_SetZoomLevel(GetRoutingID(), 0, original_zoom_level,
+                                    kZoomModeIsolated));
+    }
+  } else if (mode == kZoomModeManual) {
+    if (current_zoom_mode_ != kZoomModeDisabled) {
+      Send(new ViewMsg_SetZoomLevel(GetRoutingID(), 0, 0, kZoomModeIsolated));
+      current_zoom_mode_ = mode;
+      SetZoomLevel(original_zoom_level);
+    }
+  } else if (mode == kZoomModeDisabled) {
+    if (current_zoom_mode_ != kZoomModeManual) {
+      Send(new ViewMsg_SetZoomLevel(GetRoutingID(), 0, 0, kZoomModeIsolated));
+    }
+  } else {
+    NOTREACHED();
+  }
+
+  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 314 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) {
+  if (load_details.is_navigation_to_different_page()) {

[Fady Samuel, 2014/04/10 14:27:25]

A comment here would be useful.

[paulmeyer, 2014/04/10 15:11:49]

Done.

+    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