IPC_MESSAGE_HANDLER(AtomViewHostMsg_Message, OnRendererMessage)
IPC_MESSAGE_HANDLER_DELAY_REPLY(AtomViewHostMsg_Message_Sync,
OnRendererMessageSync)
+ IPC_MESSAGE_HANDLER_DELAY_REPLY(AtomViewHostMsg_SetTemporaryZoomLevel,
+ OnSetTemporaryZoomLevel)
+ IPC_MESSAGE_HANDLER_DELAY_REPLY(AtomViewHostMsg_GetZoomLevel,
+ OnGetZoomLevel)
IPC_MESSAGE_HANDLER_CODE(ViewHostMsg_SetCursor, OnCursorChange,
handled = false)
IPC_MESSAGE_UNHANDLED(handled = false)
return content::ZoomLevelToZoomFactor(level);
}
+void WebContents::OnSetTemporaryZoomLevel(double level,
+ IPC::Message* reply_msg) {
+ zoom_controller_->SetTemporaryZoomLevel(level);
+ double new_level = zoom_controller_->GetTemporaryZoomLevel();
+ AtomViewHostMsg_SetTemporaryZoomLevel::WriteReplyParams(reply_msg, new_level);
+ Send(reply_msg);
+}
+
+void WebContents::OnGetZoomLevel(IPC::Message* reply_msg) {
+ AtomViewHostMsg_GetZoomLevel::WriteReplyParams(reply_msg, GetZoomLevel());
+ Send(reply_msg);
+}
+
v8::Local<v8::Value> WebContents::GetWebPreferences(v8::Isolate* isolate) {
WebContentsPreferences* web_preferences =
WebContentsPreferences::FromWebContents(web_contents());
const base::ListValue& args,
IPC::Message* message);
+ // Called when received a synchronous message from renderer to
+ // set temporary zoom level.
+ void OnSetTemporaryZoomLevel(double level, IPC::Message* reply_msg);
+
+ // Called when received a synchronous message from renderer to
+ // get the zoom level.
+ void OnGetZoomLevel(IPC::Message* reply_msg);
+
v8::Global<v8::Value> session_;
v8::Global<v8::Value> devtools_web_contents_;
v8::Global<v8::Value> debugger_;
content::WebContents* web_contents)
: 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)));
if (!web_contents()->GetRenderViewHost()->IsRenderViewLive() ||
content::ZoomValuesEqual(GetZoomLevel(), level))
return;
+
+ if (!content::ZoomValuesEqual(GetTemporaryZoomLevel(), content::kEpsilon)) {
+ temporary_zoom_level_ = content::kEpsilon;
+ }
+
auto new_zoom_factor = content::ZoomLevelToZoomFactor(level);
content::NavigationEntry* entry =
web_contents()->GetController().GetLastCommittedEntry();
content::HostZoomMap::SetZoomLevel(web_contents(), level);
// Notify observers of zoom level changes.
FOR_EACH_OBSERVER(WebContentsZoomController::Observer, observers_,
- OnZoomLevelChanged(web_contents(), level));
+ OnZoomLevelChanged(web_contents(), level, false));
}
}
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();
+ int render_view_id = web_contents()->GetRenderViewHost()->GetRoutingID();
+ host_zoom_map_->SetTemporaryZoomLevel(render_process_id, render_view_id,
+ 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(
+ 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);
+}
+
void WebContentsZoomController::DidFinishNavigation(
content::NavigationHandle* navigation_handle) {
if (!navigation_handle->IsInMainFrame() || !navigation_handle->HasCommitted())
if (content::ZoomValuesEqual(GetDefaultZoomFactor(), content::kEpsilon))
return;
+ if (!content::ZoomValuesEqual(GetTemporaryZoomLevel(), content::kEpsilon)) {
+ FOR_EACH_OBSERVER(
+ WebContentsZoomController::Observer, observers_,
+ OnZoomLevelChanged(web_contents(), GetTemporaryZoomLevel(), true));
+ temporary_zoom_level_ = content::kEpsilon;
+ return;
+ }
+
// When kZoomFactor is available, it takes precedence over
// pref store values but if the host has zoom factor set explicitly
// then it takes precendence.
#ifndef ATOM_BROWSER_WEB_CONTENTS_ZOOM_CONTROLLER_H_
#define ATOM_BROWSER_WEB_CONTENTS_ZOOM_CONTROLLER_H_
+#include <map>
+#include <string>
+
#include "content/public/browser/host_zoom_map.h"
#include "content/public/browser/web_contents_observer.h"
#include "content/public/browser/web_contents_user_data.h"
class Observer {
public:
virtual void OnZoomLevelChanged(content::WebContents* web_contents,
- double level) {}
+ double level,
+ bool is_temporary) {}
protected:
virtual ~Observer() {}
double GetZoomLevel();
void SetDefaultZoomFactor(double factor);
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,
// kZoomFactor.
double default_zoom_factor_;
+ double temporary_zoom_level_;
// Map between zoom factor and hosts in this webContent.
std::map<std::string, double> host_zoom_factor_;
embedder_zoom_controller_ =
WebContentsZoomController::FromWebContents(embedder_web_contents_);
embedder_zoom_controller_->AddObserver(this);
+ if (embedder_zoom_controller_->UsesTemporaryZoomLevel()) {
+ double level = embedder_zoom_controller_->GetTemporaryZoomLevel();
+ api_web_contents_->GetZoomController()->SetTemporaryZoomLevel(level);
+ }
}
content::WebContents* WebViewGuestDelegate::GetOwnerWebContents() const {
void WebViewGuestDelegate::OnZoomLevelChanged(
content::WebContents* web_contents,
- double level) {
+ double level,
+ bool is_temporary) {
if (web_contents == GetOwnerWebContents()) {
- api_web_contents_->GetZoomController()->SetZoomLevel(level);
+ if (is_temporary) {
+ api_web_contents_->GetZoomController()->SetTemporaryZoomLevel(level);
+ } else {
+ api_web_contents_->GetZoomController()->SetZoomLevel(level);
+ }
}
}
// WebContentsZoomController::Observer:
void OnZoomLevelChanged(content::WebContents* web_contents,
- double level) override;
+ double level,
+ bool is_temporary) override;
private:
// This method is invoked when the contents auto-resized to give the container
// Update renderer process preferences.
IPC_MESSAGE_CONTROL1(AtomMsg_UpdatePreferences, base::ListValue)
+
+// Sent by renderer to set the temporary zoom level.
+IPC_SYNC_MESSAGE_ROUTED1_1(AtomViewHostMsg_SetTemporaryZoomLevel,
+ double /* zoom level */,
+ double /* result */)
+
+// Sent by renderer to get the zoom level.
+IPC_SYNC_MESSAGE_ROUTED0_1(AtomViewHostMsg_GetZoomLevel, double /* result */)
#include "atom/renderer/api/atom_api_web_frame.h"
+#include "atom/common/api/api_messages.h"
#include "atom/common/api/event_emitter_caller.h"
#include "atom/common/native_mate_converters/blink_converter.h"
#include "atom/common/native_mate_converters/callback.h"
}
double WebFrame::SetZoomLevel(double level) {
- double ret = web_frame_->view()->setZoomLevel(level);
- mate::EmitEvent(isolate(), GetWrapper(), "zoom-level-changed", ret);
- return ret;
+ double result;
+ content::RenderView* render_view =
+ content::RenderView::FromWebView(web_frame_->view());
+ render_view->Send(new AtomViewHostMsg_SetTemporaryZoomLevel(
+ render_view->GetRoutingID(), level, &result));
+ return result;
}
double WebFrame::GetZoomLevel() const {
- return web_frame_->view()->zoomLevel();
+ double result;
+ content::RenderView* render_view =
+ content::RenderView::FromWebView(web_frame_->view());
+ render_view->Send(
+ new AtomViewHostMsg_GetZoomLevel(render_view->GetRoutingID(), &result));
+ return result;
}
double WebFrame::SetZoomFactor(double factor) {
this.viewInstanceId = getNextId()
shadowRoot.appendChild(this.browserPluginNode)
- // Subscribe to host's zoom level changes.
- this.onZoomLevelChanged = (zoomLevel) => {
- this.webviewNode.setZoomLevel(zoomLevel)
- }
- webFrame.on('zoom-level-changed', this.onZoomLevelChanged)
-
this.onVisibilityChanged = (event, visibilityState) => {
this.webviewNode.send('ELECTRON_RENDERER_WINDOW_VISIBILITY_CHANGE', visibilityState)
}
// Resets some state upon reattaching <webview> element to the DOM.
reset () {
- // Unlisten the zoom-level-changed event.
- webFrame.removeListener('zoom-level-changed', this.onZoomLevelChanged)
ipcRenderer.removeListener('ELECTRON_RENDERER_WINDOW_VISIBILITY_CHANGE', this.onVisibilityChanged)
// If guestInstanceId is defined then the <webview> has navigated and has
buildParams () {
const params = {
instanceId: this.viewInstanceId,
- userAgentOverride: this.userAgentOverride,
+ userAgentOverride: this.userAgentOverride
}
for (const attributeName in this.attributes) {
if (hasProp.call(this.attributes, attributeName)) {