Introduce the abstract class WebViewBase, to decouple WebViewImpl.

third_party/WebKit/Source/web/FullscreenController.cpp

 /*
  * Copyright (C) 2013 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 14 matching lines @@
  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #include "web/FullscreenController.h"
 
 #include "core/dom/Document.h"
 #include "core/dom/Fullscreen.h"
+#include "core/exported/WebViewBase.h"
 #include "core/frame/FrameView.h"
 #include "core/frame/LocalFrame.h"
 #include "core/frame/PageScaleConstraintsSet.h"
 #include "core/html/HTMLVideoElement.h"
 #include "core/layout/LayoutFullScreen.h"
+#include "core/page/Page.h"
 #include "public/platform/WebLayerTreeView.h"
 #include "public/web/WebFrameClient.h"
 #include "web/WebLocalFrameImpl.h"
-#include "web/WebViewImpl.h"
 
 namespace blink {
 
 namespace {
 
 WebFrameClient& GetWebFrameClient(LocalFrame& frame) {
   WebLocalFrameImpl* web_frame = WebLocalFrameImpl::FromFrame(frame);
   DCHECK(web_frame);
   DCHECK(web_frame->Client());
   return *web_frame->Client();
 }
 
 }  // anonymous namespace
 
 std::unique_ptr<FullscreenController> FullscreenController::Create(
-    WebViewImpl* web_view_impl) {
-  return WTF::WrapUnique(new FullscreenController(web_view_impl));
+    WebViewBase* web_view_base) {
+  return WTF::WrapUnique(new FullscreenController(web_view_base));
 }
 
-FullscreenController::FullscreenController(WebViewImpl* web_view_impl)
-    : web_view_impl_(web_view_impl) {}
+FullscreenController::FullscreenController(WebViewBase* web_view_base)
+    : web_view_base_(web_view_base) {}
 
 void FullscreenController::DidEnterFullscreen() {
   // |Browser::EnterFullscreenModeForTab()| can enter fullscreen without going
   // through |Fullscreen::requestFullscreen()|, in which case there will be no
   // fullscreen element. Do nothing.
   if (state_ != State::kEnteringFullscreen)
     return;
 
   UpdatePageScaleConstraints(false);
-  web_view_impl_->SetPageScaleFactor(1.0f);
-  if (web_view_impl_->MainFrame()->IsWebLocalFrame())
-    web_view_impl_->MainFrame()->SetScrollOffset(WebSize());
-  web_view_impl_->SetVisualViewportOffset(FloatPoint());
+  web_view_base_->SetPageScaleFactor(1.0f);
+  if (web_view_base_->MainFrame()->IsWebLocalFrame())
+    web_view_base_->MainFrame()->SetScrollOffset(WebSize());
+  web_view_base_->SetVisualViewportOffset(FloatPoint());
 
   state_ = State::kFullscreen;
 
   // Notify all local frames that we have entered fullscreen.
-  for (Frame* frame = web_view_impl_->GetPage()->MainFrame(); frame;
+  for (Frame* frame = web_view_base_->GetPage()->MainFrame(); frame;
        frame = frame->Tree().TraverseNext()) {
     if (!frame->IsLocalFrame())
       continue;
     if (Document* document = ToLocalFrame(frame)->GetDocument()) {
       if (Fullscreen* fullscreen = Fullscreen::FromIfExists(*document))
         fullscreen->DidEnterFullscreen();
     }
   }
 }
 
@@ skipping 13 matching lines @@
   // TODO(foolip): Remove this when state changes and events are synchronized
   // with animation frames. https://crbug.com/402376
   state_ = State::kExitingFullscreen;
 
   // Notify all local frames that we have exited fullscreen.
   // TODO(foolip): This should only need to notify the topmost local roots. That
   // doesn't currently work because |Fullscreen::m_currentFullScreenElement|
   // isn't set for the topmost document when an iframe goes fullscreen, but can
   // be done once |m_currentFullScreenElement| is gone and all state is in the
   // fullscreen element stack. https://crbug.com/402421
-  for (Frame* frame = web_view_impl_->GetPage()->MainFrame(); frame;
+  for (Frame* frame = web_view_base_->GetPage()->MainFrame(); frame;
        frame = frame->Tree().TraverseNext()) {
     if (!frame->IsLocalFrame())
       continue;
     if (Document* document = ToLocalFrame(frame)->GetDocument()) {
       if (Fullscreen* fullscreen = Fullscreen::FromIfExists(*document))
         fullscreen->DidExitFullscreen();
     }
   }
 
   // We need to wait until style and layout are updated in order to properly
@@ skipping 13 matching lines @@
     state_ = old_state;
     return;
   }
 
   // We need to store these values here rather than in |didEnterFullscreen()|
   // since by the time the latter is called, a Resize has already occured,
   // clamping the scroll offset. Don't save values if we're still waiting to
   // restore a previous set. This can happen if we exit and quickly reenter
   // fullscreen without performing a layout.
   if (state_ == State::kInitial) {
-    initial_page_scale_factor_ = web_view_impl_->PageScaleFactor();
+    initial_page_scale_factor_ = web_view_base_->PageScaleFactor();
     initial_scroll_offset_ =
-        web_view_impl_->MainFrame()->IsWebLocalFrame()
-            ? web_view_impl_->MainFrame()->GetScrollOffset()
+        web_view_base_->MainFrame()->IsWebLocalFrame()
+            ? web_view_base_->MainFrame()->GetScrollOffset()
             : WebSize();
-    initial_visual_viewport_offset_ = web_view_impl_->VisualViewportOffset();
+    initial_visual_viewport_offset_ = web_view_base_->VisualViewportOffset();
     initial_background_color_override_enabled_ =
-        web_view_impl_->BackgroundColorOverrideEnabled();
+        web_view_base_->BackgroundColorOverrideEnabled();
     initial_background_color_override_ =
-        web_view_impl_->BackgroundColorOverride();
+        web_view_base_->BackgroundColorOverride();
   }
 
   // If already entering fullscreen, just wait.
   if (state_ == State::kEnteringFullscreen)
     return;
 
   DCHECK(state_ == State::kInitial ||
          state_ == State::kNeedsScrollAndScaleRestore);
   GetWebFrameClient(frame).EnterFullscreen();
 
@@ skipping 24 matching lines @@
   if (to_element) {
     DCHECK(Fullscreen::IsCurrentFullScreenElement(*to_element));
 
     if (isHTMLVideoElement(*to_element)) {
       HTMLVideoElement& video_element = toHTMLVideoElement(*to_element);
       video_element.DidEnterFullscreen();
 
       // If the video uses overlay fullscreen mode, make the background
       // transparent.
       if (video_element.UsesOverlayFullscreenVideo())
-        web_view_impl_->SetBackgroundColorOverride(Color::kTransparent);
+        web_view_base_->SetBackgroundColorOverride(Color::kTransparent);
     }
   }
 
   if (from_element) {
     DCHECK(!Fullscreen::IsCurrentFullScreenElement(*from_element));
 
     if (isHTMLVideoElement(*from_element)) {
       HTMLVideoElement& video_element = toHTMLVideoElement(*from_element);
       video_element.DidExitFullscreen();
     }
   }
 }
 
 void FullscreenController::RestoreBackgroundColorOverride() {
-  if (web_view_impl_->BackgroundColorOverrideEnabled() !=
+  if (web_view_base_->BackgroundColorOverrideEnabled() !=
           initial_background_color_override_enabled_ ||
-      web_view_impl_->BackgroundColorOverride() !=
+      web_view_base_->BackgroundColorOverride() !=
           initial_background_color_override_) {
     if (initial_background_color_override_enabled_) {
-      web_view_impl_->SetBackgroundColorOverride(
+      web_view_base_->SetBackgroundColorOverride(
           initial_background_color_override_);
     } else {
-      web_view_impl_->ClearBackgroundColorOverride();
+      web_view_base_->ClearBackgroundColorOverride();
     }
   }
 }
 
 void FullscreenController::UpdateSize() {
-  DCHECK(web_view_impl_->GetPage());
+  DCHECK(web_view_base_->GetPage());
 
   if (state_ != State::kFullscreen && state_ != State::kExitingFullscreen)
     return;
 
   UpdatePageScaleConstraints(false);
 
   // Traverse all local frames and notify the LayoutFullScreen object, if any.
-  for (Frame* frame = web_view_impl_->GetPage()->MainFrame(); frame;
+  for (Frame* frame = web_view_base_->GetPage()->MainFrame(); frame;
        frame = frame->Tree().TraverseNext()) {
     if (!frame->IsLocalFrame())
       continue;
     if (Document* document = ToLocalFrame(frame)->GetDocument()) {
       if (Fullscreen* fullscreen = Fullscreen::FromIfExists(*document)) {
         if (LayoutFullScreen* layout_object =
                 fullscreen->FullScreenLayoutObject())
           layout_object->UpdateStyle();
       }
     }
   }
 }
 
 void FullscreenController::DidUpdateLayout() {
   if (state_ != State::kNeedsScrollAndScaleRestore)
     return;
 
-  web_view_impl_->SetPageScaleFactor(initial_page_scale_factor_);
-  if (web_view_impl_->MainFrame()->IsWebLocalFrame())
-    web_view_impl_->MainFrame()->SetScrollOffset(
+  web_view_base_->SetPageScaleFactor(initial_page_scale_factor_);
+  if (web_view_base_->MainFrame()->IsWebLocalFrame())
+    web_view_base_->MainFrame()->SetScrollOffset(
         WebSize(initial_scroll_offset_));
-  web_view_impl_->SetVisualViewportOffset(initial_visual_viewport_offset_);
+  web_view_base_->SetVisualViewportOffset(initial_visual_viewport_offset_);
   // Background color override was already restored when
   // fullscreenElementChanged([..], nullptr) was called while exiting.
 
   state_ = State::kInitial;
 }
 
 void FullscreenController::UpdatePageScaleConstraints(bool remove_constraints) {
   PageScaleConstraints fullscreen_constraints;
   if (!remove_constraints) {
     fullscreen_constraints = PageScaleConstraints(1.0, 1.0, 1.0);
-    fullscreen_constraints.layout_size = FloatSize(web_view_impl_->Size());
+    fullscreen_constraints.layout_size = FloatSize(web_view_base_->Size());
   }
-  web_view_impl_->GetPageScaleConstraintsSet().SetFullscreenConstraints(
+  web_view_base_->GetPageScaleConstraintsSet().SetFullscreenConstraints(
       fullscreen_constraints);
-  web_view_impl_->GetPageScaleConstraintsSet().ComputeFinalConstraints();
+  web_view_base_->GetPageScaleConstraintsSet().ComputeFinalConstraints();
 
   // Although we called |computedFinalConstraints()| above, the "final"
   // constraints are not actually final. They are still subject to scale factor
   // clamping by contents size. Normally they should be dirtied due to contents
   // size mutation after layout, however the contents size is not guaranteed to
   // mutate, and the scale factor may remain unclamped. Just fire the event
   // again to ensure the final constraints pick up the latest contents size.
-  web_view_impl_->DidChangeContentsSize();
-  if (web_view_impl_->MainFrameImpl() &&
-      web_view_impl_->MainFrameImpl()->GetFrameView())
-    web_view_impl_->MainFrameImpl()->GetFrameView()->SetNeedsLayout();
+  web_view_base_->DidChangeContentsSize();
+  if (web_view_base_->MainFrameImpl() &&
+      web_view_base_->MainFrameImpl()->GetFrameView())
+    web_view_base_->MainFrameImpl()->GetFrameView()->SetNeedsLayout();
 
-  web_view_impl_->UpdateMainFrameLayoutSize();
+  web_view_base_->UpdateMainFrameLayoutSize();
 }
 
 }  // namespace blink