simply handling temporary zoom levels of webview

atom/browser/api/atom_api_web_contents.cc

@@ -1530,7 +1530,7 @@ double WebContents::GetZoomFactor() {
 void WebContents::OnSetTemporaryZoomLevel(double level,
                                           IPC::Message* reply_msg) {
   zoom_controller_->SetTemporaryZoomLevel(level);
-  double new_level = zoom_controller_->GetTemporaryZoomLevel();
+  double new_level = zoom_controller_->GetZoomLevel();
   AtomViewHostMsg_SetTemporaryZoomLevel::WriteReplyParams(reply_msg, new_level);
   Send(reply_msg);
 }

atom/browser/web_contents_zoom_controller.cc

@@ -7,6 +7,7 @@
 #include "content/public/browser/navigation_details.h"
 #include "content/public/browser/navigation_entry.h"
 #include "content/public/browser/navigation_handle.h"
+#include "content/public/browser/render_frame_host.h"
 #include "content/public/browser/render_process_host.h"
 #include "content/public/browser/render_view_host.h"
 #include "content/public/browser/web_contents.h"
@@ -20,15 +21,19 @@ namespace atom {
 
 WebContentsZoomController::WebContentsZoomController(
     content::WebContents* web_contents)
-    : content::WebContentsObserver(web_contents) {
+    : old_process_id_(-1),
+      old_view_id_(-1),
+      embedder_zoom_controller_(nullptr),
+      content::WebContentsObserver(web_contents) {
   default_zoom_factor_ = content::kEpsilon;
-  temporary_zoom_level_ = content::kEpsilon;
   host_zoom_map_ = content::HostZoomMap::GetForWebContents(web_contents);
   zoom_subscription_ = host_zoom_map_->AddZoomLevelChangedCallback(base::Bind(
       &WebContentsZoomController::OnZoomLevelChanged, base::Unretained(this)));
 }
 
-WebContentsZoomController::~WebContentsZoomController() {}
+WebContentsZoomController::~WebContentsZoomController() {
+  embedder_zoom_controller_ = nullptr;
+}
 
 void WebContentsZoomController::AddObserver(
     WebContentsZoomController::Observer* observer) {
@@ -40,13 +45,21 @@ void WebContentsZoomController::RemoveObserver(
   observers_.RemoveObserver(observer);
 }
 
+void WebContentsZoomController::SetEmbedderZoomController(
+    WebContentsZoomController* controller) {
+  embedder_zoom_controller_ = controller;
+}
+
 void WebContentsZoomController::SetZoomLevel(double level) {
   if (!web_contents()->GetRenderViewHost()->IsRenderViewLive() ||
       content::ZoomValuesEqual(GetZoomLevel(), level))
     return;
 
-  if (!content::ZoomValuesEqual(GetTemporaryZoomLevel(), content::kEpsilon)) {
+  int render_process_id = web_contents()->GetRenderProcessHost()->GetID();
-    temporary_zoom_level_ = content::kEpsilon;
+  int render_view_id = web_contents()->GetRenderViewHost()->GetRoutingID();
+  if (host_zoom_map_->UsesTemporaryZoomLevel(render_process_id,
+                                             render_view_id)) {
+    host_zoom_map_->ClearTemporaryZoomLevel(render_process_id, render_view_id);
   }
 
   auto new_zoom_factor = content::ZoomLevelToZoomFactor(level);
@@ -76,32 +89,20 @@ double WebContentsZoomController::GetDefaultZoomFactor() {
   return default_zoom_factor_;
 }
 
-bool WebContentsZoomController::UsesTemporaryZoomLevel() {
-  return !content::ZoomValuesEqual(temporary_zoom_level_, content::kEpsilon);
-}
-
-double WebContentsZoomController::GetTemporaryZoomLevel() {
-  return temporary_zoom_level_;
-}
-
 void WebContentsZoomController::SetTemporaryZoomLevel(double level) {
-  int render_process_id = web_contents()->GetRenderProcessHost()->GetID();
+  old_process_id_ = web_contents()->GetRenderProcessHost()->GetID();
-  int render_view_id = web_contents()->GetRenderViewHost()->GetRoutingID();
+  old_view_id_ = web_contents()->GetRenderViewHost()->GetRoutingID();
-  host_zoom_map_->SetTemporaryZoomLevel(render_process_id, render_view_id,
+  host_zoom_map_->SetTemporaryZoomLevel(old_process_id_, old_view_id_, level);
-                                        level);
-  temporary_zoom_level_ = level;
   // Notify observers of zoom level changes.
   FOR_EACH_OBSERVER(WebContentsZoomController::Observer, observers_,
                     OnZoomLevelChanged(web_contents(), level, true));
 }
 
-void WebContentsZoomController::DidStartNavigation(
+bool WebContentsZoomController::UsesTemporaryZoomLevel() {
-    content::NavigationHandle* navigation_handle) {
-  if (!navigation_handle->IsInMainFrame() || navigation_handle->IsSamePage())
-    return;
   int render_process_id = web_contents()->GetRenderProcessHost()->GetID();
   int render_view_id = web_contents()->GetRenderViewHost()->GetRoutingID();
-  host_zoom_map_->ClearTemporaryZoomLevel(render_process_id, render_view_id);
+  return host_zoom_map_->UsesTemporaryZoomLevel(render_process_id,
+                                                render_view_id);
 }
 
 void WebContentsZoomController::DidFinishNavigation(
@@ -142,11 +143,14 @@ void WebContentsZoomController::SetZoomFactorOnNavigationIfNeeded(
   if (content::ZoomValuesEqual(GetDefaultZoomFactor(), content::kEpsilon))
     return;
 
-  if (!content::ZoomValuesEqual(GetTemporaryZoomLevel(), content::kEpsilon)) {
+  if (host_zoom_map_->UsesTemporaryZoomLevel(old_process_id_, old_view_id_)) {
-    FOR_EACH_OBSERVER(
+    host_zoom_map_->ClearTemporaryZoomLevel(old_process_id_, old_view_id_);
-        WebContentsZoomController::Observer, observers_,
+  }
-        OnZoomLevelChanged(web_contents(), GetTemporaryZoomLevel(), true));
+
-    temporary_zoom_level_ = content::kEpsilon;
+  if (embedder_zoom_controller_ &&
+      embedder_zoom_controller_->UsesTemporaryZoomLevel()) {
+    double level = embedder_zoom_controller_->GetZoomLevel();
+    SetTemporaryZoomLevel(level);
     return;
   }
 

atom/browser/web_contents_zoom_controller.h

@@ -35,6 +35,8 @@ class WebContentsZoomController
   void AddObserver(Observer* observer);
   void RemoveObserver(Observer* observer);
 
+  void SetEmbedderZoomController(WebContentsZoomController* controller);
+
   // Methods for managing zoom levels.
   void SetZoomLevel(double level);
   double GetZoomLevel();
@@ -42,11 +44,9 @@ class WebContentsZoomController
   double GetDefaultZoomFactor();
   void SetTemporaryZoomLevel(double level);
   bool UsesTemporaryZoomLevel();
-  double GetTemporaryZoomLevel();
 
  protected:
   // content::WebContentsObserver:
-  void DidStartNavigation(content::NavigationHandle* handle) override;
   void DidFinishNavigation(content::NavigationHandle* handle) override;
   void WebContentsDestroyed() override;
   void RenderFrameHostChanged(content::RenderFrameHost* old_host,
@@ -65,6 +65,11 @@ class WebContentsZoomController
   double default_zoom_factor_;
   double temporary_zoom_level_;
 
+  int old_process_id_;
+  int old_view_id_;
+
+  WebContentsZoomController* embedder_zoom_controller_;
+
   // Map between zoom factor and hosts in this webContent.
   std::map<std::string, double> host_zoom_factor_;
 

atom/browser/web_view_guest_delegate.cc

@@ -111,11 +111,9 @@ void WebViewGuestDelegate::DidAttach(int guest_proxy_routing_id) {
   api_web_contents_->Emit("did-attach");
   embedder_zoom_controller_ =
       WebContentsZoomController::FromWebContents(embedder_web_contents_);
+  auto zoom_controller = api_web_contents_->GetZoomController();
   embedder_zoom_controller_->AddObserver(this);
-  if (embedder_zoom_controller_->UsesTemporaryZoomLevel()) {
+  zoom_controller->SetEmbedderZoomController(embedder_zoom_controller_);
-    double level = embedder_zoom_controller_->GetTemporaryZoomLevel();
-    api_web_contents_->GetZoomController()->SetTemporaryZoomLevel(level);
-  }
 }
 
 content::WebContents* WebViewGuestDelegate::GetOwnerWebContents() const {
@@ -153,6 +151,9 @@ void WebViewGuestDelegate::OnZoomLevelChanged(
     } else {
       api_web_contents_->GetZoomController()->SetZoomLevel(level);
     }
+    // Change the default zoom factor to match the embedders' new zoom level.
+    double zoom_factor = content::ZoomLevelToZoomFactor(level);
+    api_web_contents_->GetZoomController()->SetDefaultZoomFactor(zoom_factor);
   }
 }