Move ZoomController out of ChromeWebViewGuestDelegate.

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/zoom_controller.h"
 #include "content/public/browser/navigation_details.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"
+#include "content/public/common/page_zoom.h"
 #include "content/public/common/url_constants.h"
 #include "extensions/browser/api/extensions_api_client.h"
 #include "extensions/browser/event_router.h"
 #include "extensions/browser/extension_registry.h"
 #include "extensions/browser/guest_view/app_view/app_view_guest.h"
 #include "extensions/browser/guest_view/extension_options/extension_options_guest.h"
 #include "extensions/browser/guest_view/guest_view_manager.h"
 #include "extensions/browser/guest_view/mime_handler_view/mime_handler_view_guest.h"
 #include "extensions/browser/guest_view/web_view/web_view_guest.h"
 #include "extensions/browser/guest_view/worker_frame/worker_frame_guest.h"
@@ skipping 70 matching lines @@
 
  private:
   bool destroyed_;
   GuestViewBase* guest_;
 
   void Destroy() {
     if (destroyed_)
       return;
 
     destroyed_ = true;
+    guest_->StopObservingOwnersZoomControllerIfNecessary();

[Fady Samuel, 2014/12/11 23:18:11]

Move this to GuestViewBase::Destroy then you don't need to call it from multiple
call sites.

[wjmaclean, 2014/12/11 23:45:24]

Ok, but then we have to preserver owner_weeb_contents_ until after the call to
Destroy().

[Fady Samuel, 2014/12/12 00:03:46]

OK, that seems fine. I can't think of reason for that to be a problem.

     guest_->EmbedderWillBeDestroyed();
     guest_->owner_web_contents_ = NULL;
     guest_->Destroy();
   }
 
   DISALLOW_COPY_AND_ASSIGN(OwnerLifetimeObserver);
 };
 
 // This observer ensures that the GuestViewBase destroys itself when its
 // embedder goes away.
@@ skipping 25 matching lines @@
                              int guest_instance_id)
     : owner_web_contents_(owner_web_contents),
       browser_context_(browser_context),
       guest_instance_id_(guest_instance_id),
       view_instance_id_(guestview::kInstanceIDNone),
       element_instance_id_(guestview::kInstanceIDNone),
       initialized_(false),
       is_being_destroyed_(false),
       auto_size_enabled_(false),
       is_full_page_plugin_(false),
+      observing_owners_zoom_controller_(false),

[Fady Samuel, 2014/12/11 23:18:12]

Is this necessary?

[wjmaclean, 2014/12/11 23:45:24]

Yes ... I think we need to make sure we can detect if a GVB is ever destructed
with its owners_web_contents_ cleared without removing the observer on the
ZoomController.

[Fady Samuel, 2014/12/12 00:03:46]

GuestViewBase should always have an owner_web_contents_ at this point. After
your move in OwnerLifetimeObserver::Destroy, this should always be the case.

       weak_ptr_factory_(this) {
 }
 
 void GuestViewBase::Init(const std::string& owner_extension_id,
                          const base::DictionaryValue& create_params,
                          const WebContentsCreatedCallback& callback) {
   if (initialized_)
     return;
   initialized_ = true;
 
@@ skipping 43 matching lines @@
   owner_lifetime_observer_.reset(
       new OwnerLifetimeObserver(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);
+
   // Give the derived class an opportunity to perform additional initialization.
   DidInitialize();
 }
 
 void GuestViewBase::SetAutoSize(bool enabled,
                                 const gfx::Size& min_size,
                                 const gfx::Size& max_size) {
   min_auto_size_ = min_size;
   min_auto_size_.SetToMin(max_size);
   max_auto_size_ = max_size;
@@ skipping 80 matching lines @@
   return false;
 }
 
 bool GuestViewBase::IsDragAndDropEnabled() const {
   return false;
 }
 
 void GuestViewBase::DidAttach(int guest_proxy_routing_id) {
   opener_lifetime_observer_.reset();
 
+  // Any zoom events from the embedder should be relayed to the guest.
+  StartObservingOwnersZoomController();
+
   // Give the derived class an opportunity to perform some actions.
   DidAttachToEmbedder();
 
   // Inform the associated GuestViewContainer that the contentWindow is ready.
   embedder_web_contents()->Send(new ExtensionMsg_GuestAttached(
       embedder_web_contents()->GetMainFrame()->GetRoutingID(),
       element_instance_id_,
       guest_proxy_routing_id));
 
   SendQueuedEvents();
@@ skipping 154 matching lines @@
 }
 
 bool GuestViewBase::PreHandleGestureEvent(content::WebContents* source,
                                          const blink::WebGestureEvent& event) {
   return event.type == blink::WebGestureEvent::GesturePinchBegin ||
       event.type == blink::WebGestureEvent::GesturePinchUpdate ||
       event.type == blink::WebGestureEvent::GesturePinchEnd;
 }
 
 GuestViewBase::~GuestViewBase() {
+  StopObservingOwnersZoomControllerIfNecessary();

[Fady Samuel, 2014/12/11 23:18:12]

This should be in Destroy.

[wjmaclean, 2014/12/11 23:45:24]

OK. Then we are *guaranteed* never to call the destructor without call Destroy()
first?

[Fady Samuel, 2014/12/12 00:03:46]

Yes, ~GuestViewBase is protected, and in derived types it's protected. The only
way to delete a GuestViewBase is to call Destroy()

[Fady Samuel, 2014/12/12 00:07:44]

Actually the derived types' destructors are private!

+}
+
+void GuestViewBase::OnZoomChanged(
+    const ui_zoom::ZoomController::ZoomChangedEventData& data) {
+  if (content::ZoomValuesEqual(data.old_zoom_level, data.new_zoom_level))
+    return;
+
+  // When the embedder's zoom level is changed, then we also update the
+  // guest's zoom level to match.
+  ui_zoom::ZoomController::FromWebContents(web_contents())
+      ->SetZoomLevel(data.new_zoom_level);
 }
 
 void GuestViewBase::DispatchEventToEmbedder(Event* event) {
   scoped_ptr<Event> event_ptr(event);
 
   if (!attached()) {
     pending_events_.push_back(linked_ptr<Event>(event_ptr.release()));
     return;
   }
 
@@ skipping 29 matching lines @@
     // The derived class did not create a WebContents so this class serves no
     // purpose. Let's self-destruct.
     delete this;
     callback.Run(NULL);
     return;
   }
   InitWithWebContents(owner_extension_id, guest_web_contents);
   callback.Run(guest_web_contents);
 }
 
+void GuestViewBase::StartObservingOwnersZoomController() {
+  ui_zoom::ZoomController* zoom_controller =
+      ui_zoom::ZoomController::FromWebContents(embedder_web_contents());
+  if (zoom_controller) {

[Fady Samuel, 2014/12/11 23:18:11]

Early exit preferred.

[wjmaclean, 2014/12/11 23:45:24]

Done.

+    // Listen to the embedder's zoom changes.
+    zoom_controller->AddObserver(this);

[Fady Samuel, 2014/12/12 00:03:46]

A GuestViewBase's owner/embedder can change during its lifetime. You probably
want to remove the observer here. In fact, now that I think about it, you
probably want to call this in GuestViewBase::WillAttach instead of DidAttach.
That way you can see what the old owner was and remove the observer from the old
owner.

+    observing_owners_zoom_controller_ = true;
+    // Set the guest's initial zoom level to be equal to the embedder's.
+    ui_zoom::ZoomController::FromWebContents(web_contents())
+        ->SetZoomLevel(zoom_controller->GetZoomLevel());
+  }
+}
+
+void GuestViewBase::StopObservingOwnersZoomControllerIfNecessary() {
+  // We use owner_web_contents_ below and not embedder_web_contents() since
+  // we may have been detached by this point.
+  DCHECK(!observing_owners_zoom_controller_ || owner_web_contents_);
+  if (!owner_web_contents_ || !observing_owners_zoom_controller_)
+    return;
+
+  ui_zoom::ZoomController* zoom_controller =
+      ui_zoom::ZoomController::FromWebContents(owner_web_contents_);
+  zoom_controller->RemoveObserver(this);
+  observing_owners_zoom_controller_ = false;
+}
+
 // static
 void GuestViewBase::RegisterGuestViewTypes() {
   AppViewGuest::Register();
   ExtensionOptionsGuest::Register();
   MimeHandlerViewGuest::Register();
   WebViewGuest::Register();
   WorkerFrameGuest::Register();
 }
 
 }  // namespace extensions