Make options zoom isolated, match embedder zoom on navigation.

extensions/browser/guest_view/guest_view_base.cc

 // Copyright 2014 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 "extensions/browser/guest_view/guest_view_base.h"
 
 #include "base/lazy_instance.h"
 #include "base/strings/utf_string_conversions.h"
 #include "components/ui/zoom/page_zoom.h"
 #include "components/ui/zoom/zoom_controller.h"
@@ skipping 215 matching lines @@
                                weak_ptr_factory_.GetWeakPtr(),
                                base::Passed(&params),
                                callback));
 }
 
 void GuestViewBase::InitWithWebContents(
     const base::DictionaryValue& create_params,
     content::WebContents* guest_web_contents) {
   DCHECK(guest_web_contents);
 
+  // Create a ZoomController to allow the guest's contents to be zoomed.
+  // Do this before adding the GuestView as a WebContents Observer so that
+  // the GuestView and its derived classes can re-configure the ZoomController
+  // after the latter has handled WebContentsObserver events.

[Fady Samuel, 2015/03/25 21:07:16]

I don't know what this means. What problem is this move solving?

[wjmaclean, 2015/03/25 21:14:33]

When multiple observers exist for a given WebContents, they are called (e.g. for
functions like DidNavigateMainFrame()) in the order they registered as
observers.

The ZoomController registers as an observer in it's constructor.

If the ZoomController's DidNavigateMainFrame() gets called after
ExtensionOptionsGuest's DidNavigateMainFrame(), then ExtensionOptionsGuest
cannot set ISOLATED_ZOOM_MODE, as that will be reset in ZoomController's
DidNavigateMainFrame().

An alternative would be to add a function to ZoomController to override the
reset behaviour (controlled by a flag in ZoomController), but this seemed easier
since both observers are being registered in the same place.

+  ui_zoom::ZoomController::CreateForWebContents(guest_web_contents);
+
   // At this point, we have just created the guest WebContents, we need to add
   // an observer to the owner WebContents. This observer will be responsible
   // for destroying the guest WebContents if the owner goes away.
   owner_contents_observer_.reset(
       new OwnerContentsObserver(this, owner_web_contents_));
 
   WebContentsObserver::Observe(guest_web_contents);
   guest_web_contents->SetDelegate(this);
   webcontents_guestview_map.Get().insert(
       std::make_pair(guest_web_contents, this));
   GuestViewManager::FromBrowserContext(browser_context_)->
       AddGuest(guest_instance_id_, guest_web_contents);
 
-  // Create a ZoomController to allow the guest's contents to be zoomed.
-  ui_zoom::ZoomController::CreateForWebContents(guest_web_contents);
-
   // Populate the view instance ID if we have it on creation.
   create_params.GetInteger(guestview::kParameterInstanceId,
                            &view_instance_id_);
 
   if (CanRunInDetachedState())
     SetUpSizing(create_params);
 
   // Give the derived class an opportunity to perform additional initialization.
   DidInitialize(create_params);
 }
@@ skipping 307 matching lines @@
   // being destroyed. web_contents() is still valid at this point.
   // TODO(fsamuel): This allows for reentrant code into WebContents during
   // destruction. This could potentially lead to bugs. Perhaps we should get rid
   // of this?
   GuestDestroyed();
 
   // Self-destruct.
   delete this;
 }
 
+void GuestViewBase::DidNavigateMainFrame(
+    const content::LoadCommittedDetails& details,
+    const content::FrameNavigateParams& params) {
+  if (attached())
+    SetGuestZoomLevelToMatchEmbedder();
+}
+
 void GuestViewBase::ActivateContents(WebContents* web_contents) {
   if (!attached() || !embedder_web_contents()->GetDelegate())
     return;
 
   embedder_web_contents()->GetDelegate()->ActivateContents(
       embedder_web_contents());
 }
 
 void GuestViewBase::DeactivateContents(WebContents* web_contents) {
   if (!attached() || !embedder_web_contents()->GetDelegate())
@@ skipping 219 matching lines @@
   set_size_params.enable_auto_size.reset(new bool(auto_size_enabled));
   set_size_params.min_size.reset(new gfx::Size(min_width, min_height));
   set_size_params.max_size.reset(new gfx::Size(max_width, max_height));
   set_size_params.normal_size.reset(new gfx::Size(normal_width, normal_height));
 
   // Call SetSize to apply all the appropriate validation and clipping of
   // values.
   SetSize(set_size_params);
 }
 
+void GuestViewBase::SetGuestZoomLevelToMatchEmbedder() {
+  auto embedder_zoom_controller =
+      ui_zoom::ZoomController::FromWebContents(owner_web_contents());
+  if (!embedder_zoom_controller)
+    return;
+
+  ui_zoom::ZoomController::FromWebContents(web_contents())
+      ->SetZoomLevel(embedder_zoom_controller->GetZoomLevel());
+}
+
 void GuestViewBase::StartTrackingEmbedderZoomLevel() {
   if (!ZoomPropagatesFromEmbedderToGuest())
     return;
 
   auto embedder_zoom_controller =
       ui_zoom::ZoomController::FromWebContents(owner_web_contents());
   // Chrome Apps do not have a ZoomController.
   if (!embedder_zoom_controller)
     return;
   // Listen to the embedder's zoom changes.
   embedder_zoom_controller->AddObserver(this);
+
   // Set the guest's initial zoom level to be equal to the embedder's.
-  ui_zoom::ZoomController::FromWebContents(web_contents())
-      ->SetZoomLevel(embedder_zoom_controller->GetZoomLevel());
+  SetGuestZoomLevelToMatchEmbedder();
 }
 
 void GuestViewBase::StopTrackingEmbedderZoomLevel() {
   if (!attached() || !ZoomPropagatesFromEmbedderToGuest())
     return;
 
   auto embedder_zoom_controller =
       ui_zoom::ZoomController::FromWebContents(owner_web_contents());
   // Chrome Apps do not have a ZoomController.
   if (!embedder_zoom_controller)
     return;
   embedder_zoom_controller->RemoveObserver(this);
 }
 
 // static
 void GuestViewBase::RegisterGuestViewTypes() {
   AppViewGuest::Register();
   ExtensionOptionsGuest::Register();
   ExtensionViewGuest::Register();
   MimeHandlerViewGuest::Register();
   SurfaceWorkerGuest::Register();
   WebViewGuest::Register();
 }
 
 }  // namespace extensions