<webview>: Implement fullscreen permission for html5 element.requestFullscreen()

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 54 matching lines @@
 }
 
 GuestViewBase::Event::~Event() {
 }
 
 scoped_ptr<base::DictionaryValue> GuestViewBase::Event::GetArguments() {
   return args_.Pass();
 }
 
 // This observer ensures that the GuestViewBase destroys itself when its
-// embedder goes away.
-class GuestViewBase::OwnerLifetimeObserver : public WebContentsObserver {
+// embedder goes away. It also tracks when the embedder's fullscreen is
+// toggled so the guest can change itself accordingly.
+class GuestViewBase::OwnerContentsObserver : public WebContentsObserver {
  public:
-  OwnerLifetimeObserver(GuestViewBase* guest,
+  OwnerContentsObserver(GuestViewBase* guest,
                         content::WebContents* embedder_web_contents)
       : WebContentsObserver(embedder_web_contents),
+        is_fullscreen_(false),
         destroyed_(false),
         guest_(guest) {}
 
-  ~OwnerLifetimeObserver() override {}
+  ~OwnerContentsObserver() override {}
 
   // WebContentsObserver implementation.
   void WebContentsDestroyed() override {
     // If the embedder is destroyed then destroy the guest.
     Destroy();
   }
 
   void DidNavigateMainFrame(
       const content::LoadCommittedDetails& details,
       const content::FrameNavigateParams& params) override {
     // If the embedder navigates to a different page then destroy the guest.
     if (details.is_navigation_to_different_page())
       Destroy();
   }
 
   void RenderProcessGone(base::TerminationStatus status) override {
     // If the embedder crashes, then destroy the guest.
     Destroy();
   }
 
+  void DidToggleFullscreenModeForTab(bool entered_fullscreen) override {
+    if (destroyed_)
+      return;
+
+    is_fullscreen_ = entered_fullscreen;
+    guest_->EmbedderFullscreenToggled(is_fullscreen_);
+  }
+
+  void MainFrameWasResized(bool width_changed) override {
+    if (destroyed_)
+      return;
+
+    if (!web_contents()->GetDelegate())
+      return;
+
+    bool current_fullscreen =
+        web_contents()->GetDelegate()->IsFullscreenForTabOrPending(
+            web_contents());
+    if (is_fullscreen_ && !current_fullscreen) {
+      is_fullscreen_ = false;
+      guest_->EmbedderFullscreenToggled(is_fullscreen_);
+    }
+  }
+
  private:
+  bool is_fullscreen_;
   bool destroyed_;
   GuestViewBase* guest_;
 
   void Destroy() {
     if (destroyed_)
       return;
 
     destroyed_ = true;
     guest_->EmbedderWillBeDestroyed();
     guest_->Destroy();
   }
 
-  DISALLOW_COPY_AND_ASSIGN(OwnerLifetimeObserver);
+  DISALLOW_COPY_AND_ASSIGN(OwnerContentsObserver);
 };
 
 // This observer ensures that the GuestViewBase destroys itself when its
 // embedder goes away.
 class GuestViewBase::OpenerLifetimeObserver : public WebContentsObserver {
  public:
   OpenerLifetimeObserver(GuestViewBase* guest)
       : WebContentsObserver(guest->GetOpener()->web_contents()),
         guest_(guest) {}
 
@@ skipping 73 matching lines @@
 }
 
 void GuestViewBase::InitWithWebContents(
     const base::DictionaryValue& create_params,
     content::WebContents* guest_web_contents) {
   DCHECK(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_lifetime_observer_.reset(
-      new OwnerLifetimeObserver(this, owner_web_contents_));
+  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);
@@ skipping 259 matching lines @@
 }
 
 void GuestViewBase::SetGuestHost(content::GuestHost* guest_host) {
   guest_host_ = guest_host;
 }
 
 void GuestViewBase::WillAttach(content::WebContents* embedder_web_contents,
                                int element_instance_id,
                                bool is_full_page_plugin) {
   if (owner_web_contents_ != embedder_web_contents) {
-    DCHECK_EQ(owner_lifetime_observer_->web_contents(), owner_web_contents_);
+    DCHECK_EQ(owner_contents_observer_->web_contents(), owner_web_contents_);
     // Stop tracking the old embedder's zoom level.
     StopTrackingEmbedderZoomLevel();
     owner_web_contents_ = embedder_web_contents;
-    owner_lifetime_observer_.reset(
-        new OwnerLifetimeObserver(this, embedder_web_contents));
+    owner_contents_observer_.reset(
+        new OwnerContentsObserver(this, embedder_web_contents));
   }
 
   // Start tracking the new embedder's zoom level.
   StartTrackingEmbedderZoomLevel();
   element_instance_id_ = element_instance_id;
   is_full_page_plugin_ = is_full_page_plugin;
 
   WillAttachToEmbedder();
 }
 
@@ skipping 310 matching lines @@
 void GuestViewBase::RegisterGuestViewTypes() {
   AppViewGuest::Register();
   ExtensionOptionsGuest::Register();
   ExtensionViewGuest::Register();
   MimeHandlerViewGuest::Register();
   SurfaceWorkerGuest::Register();
   WebViewGuest::Register();
 }
 
 }  // namespace extensions