Introduce the abstract class WebViewBase, to decouple WebViewImpl.

third_party/WebKit/Source/web/WebViewImpl.h

 /*
  * Copyright (C) 2010 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.
  */
 
 #ifndef WebViewImpl_h
 #define WebViewImpl_h
 
 #include <memory>
+#include "core/exported/WebViewBase.h"
 #include "core/frame/ResizeViewportAnchor.h"
 #include "core/page/ContextMenuProvider.h"
 #include "core/page/EventWithHitTestResults.h"
 #include "platform/animation/CompositorAnimationTimeline.h"
 #include "platform/geometry/IntPoint.h"
 #include "platform/geometry/IntRect.h"
 #include "platform/graphics/GraphicsLayer.h"
 #include "platform/heap/Handle.h"
 #include "platform/scheduler/child/web_scheduler.h"
 #include "platform/wtf/Compiler.h"
 #include "platform/wtf/HashSet.h"
 #include "platform/wtf/RefCounted.h"
 #include "platform/wtf/Vector.h"
 #include "public/platform/WebDisplayMode.h"
 #include "public/platform/WebFloatSize.h"
 #include "public/platform/WebGestureCurveTarget.h"
 #include "public/platform/WebGestureEvent.h"
 #include "public/platform/WebInputEvent.h"
 #include "public/platform/WebInputEventResult.h"
 #include "public/platform/WebLayer.h"
 #include "public/platform/WebPoint.h"
 #include "public/platform/WebRect.h"
 #include "public/platform/WebSize.h"
 #include "public/platform/WebString.h"
 #include "public/platform/WebVector.h"
 #include "public/web/WebNavigationPolicy.h"
 #include "public/web/WebPageImportanceSignals.h"
-#include "public/web/WebView.h"
 #include "web/ChromeClientImpl.h"
 #include "web/ContextMenuClientImpl.h"
 #include "web/EditorClientImpl.h"
 #include "web/MediaKeysClientImpl.h"
 #include "web/PageWidgetDelegate.h"
 #include "web/SpellCheckerClientImpl.h"
 #include "web/StorageClientImpl.h"
 #include "web/WebExport.h"
 #include "web/WebPagePopupImpl.h"
 
@@ skipping 17 matching lines @@
 class WebLayerTreeView;
 class WebLocalFrame;
 class WebLocalFrameImpl;
 class CompositorMutatorImpl;
 class WebPlugin;
 class WebRemoteFrame;
 class WebSettingsImpl;
 class WebViewScheduler;
 
 class WEB_EXPORT WebViewImpl final
-    : NON_EXPORTED_BASE(public WebView),
+    : NON_EXPORTED_BASE(public WebViewBase),
       public RefCounted<WebViewImpl>,
       NON_EXPORTED_BASE(public WebGestureCurveTarget),
       public PageWidgetEventHandler,
       public WebScheduler::InterventionReporter,
       public WebViewScheduler::WebViewSchedulerSettings {
  public:
   static WebViewImpl* Create(WebViewClient*, WebPageVisibilityState);
   static HashSet<WebViewImpl*>& AllInstances();
 
   // WebWidget methods:
@@ skipping 67 matching lines @@
   WebFrame* MainFrame() override;
   WebFrame* FindFrameByName(const WebString& name,
                             WebFrame* relative_to_frame) override;
   WebLocalFrame* FocusedFrame() override;
   void SetFocusedFrame(WebFrame*) override;
   void FocusDocumentView(WebFrame*) override;
   void SetInitialFocus(bool reverse) override;
   void ClearFocusedElement() override;
   bool ScrollFocusedEditableElementIntoRect(const WebRect&) override;
   void SmoothScroll(int target_x, int target_y, long duration_ms) override;
-  void ZoomToFindInPageRect(const WebRect&);
+  void ZoomToFindInPageRect(const WebRect&) override;
   void AdvanceFocus(bool reverse) override;
   void AdvanceFocusAcrossFrames(WebFocusType,
                                 WebRemoteFrame* from,
                                 WebLocalFrame* to) override;
   double ZoomLevel() override;
   double SetZoomLevel(double) override;
   void ZoomLimitsChanged(double minimum_zoom_level,
                          double maximum_zoom_level) override;
   float TextZoomFactor() override;
   float SetTextZoomFactor(float) override;
@@ skipping 38 matching lines @@
   void ShowContextMenu() override;
   void DidCloseContextMenu() override;
   void HidePopups() override;
   void SetPageOverlayColor(WebColor) override;
   WebPageImportanceSignals* PageImportanceSignals() override;
   void TransferActiveWheelFlingAnimation(
       const WebActiveWheelFlingParameters&) override;
   bool EndActiveFlingAnimation() override;
   bool IsFlinging() const override { return !!gesture_animation_.get(); }
   void SetShowPaintRects(bool) override;
-  void SetShowDebugBorders(bool);
+  void SetShowDebugBorders(bool) override;
   void SetShowFPSCounter(bool) override;
   void SetShowScrollBottleneckRects(bool) override;
   void AcceptLanguagesChanged() override;
 
   // WebScheduler::InterventionReporter implementation:
   void ReportIntervention(const WebString& message) override;
 
   // WebViewScheduler::WebViewSchedulerSettings implementation:
   float ExpensiveBackgroundThrottlingCPUBudget() override;
   float ExpensiveBackgroundThrottlingInitialBudget() override;
   float ExpensiveBackgroundThrottlingMaxBudget() override;
   float ExpensiveBackgroundThrottlingMaxDelay() override;
 
-  void DidUpdateFullscreenSize();
+  void DidUpdateFullscreenSize() override;
 
-  float DefaultMinimumPageScaleFactor() const;
-  float DefaultMaximumPageScaleFactor() const;
-  float MinimumPageScaleFactor() const;
-  float MaximumPageScaleFactor() const;
-  float ClampPageScaleFactorToLimits(float) const;
-  void ResetScaleStateImmediately();
+  float DefaultMinimumPageScaleFactor() const override;
+  float DefaultMaximumPageScaleFactor() const override;
+  float MinimumPageScaleFactor() const override;
+  float MaximumPageScaleFactor() const override;
+  float ClampPageScaleFactorToLimits(float) const override;
+  void ResetScaleStateImmediately() override;
 
   HitTestResult CoreHitTestResultAt(const WebPoint&);
   void InvalidateRect(const IntRect&);
 
-  void SetBaseBackgroundColor(WebColor);
-  void SetBaseBackgroundColorOverride(WebColor);
-  void ClearBaseBackgroundColorOverride();
-  void SetBackgroundColorOverride(WebColor);
-  void ClearBackgroundColorOverride();
-  void SetZoomFactorOverride(float);
-  void SetCompositorDeviceScaleFactorOverride(float);
-  void SetDeviceEmulationTransform(const TransformationMatrix&);
+  void SetBaseBackgroundColor(WebColor) override;
+  void SetBaseBackgroundColorOverride(WebColor) override;
+  void ClearBaseBackgroundColorOverride() override;
+  void SetBackgroundColorOverride(WebColor) override;
+  void ClearBackgroundColorOverride() override;
+  void SetZoomFactorOverride(float) override;
+  void SetCompositorDeviceScaleFactorOverride(float) override;
+  void SetDeviceEmulationTransform(const TransformationMatrix&) override;
   TransformationMatrix GetDeviceEmulationTransformForTesting() const;
 
-  Color BaseBackgroundColor() const;
-  bool BackgroundColorOverrideEnabled() const {
+  Color BaseBackgroundColor() const override;
+  bool BackgroundColorOverrideEnabled() const override {
     return background_color_override_enabled_;
   }
-  WebColor BackgroundColorOverride() const {
+  WebColor BackgroundColorOverride() const override {
     return background_color_override_;
   }
 
-  Frame* FocusedCoreFrame() const;
+  Frame* FocusedCoreFrame() const override;
 
   // Returns the currently focused Element or null if no element has focus.
   Element* FocusedElement() const;
 
   static WebViewImpl* FromPage(Page*);
 
-  WebViewClient* Client() { return client_; }
+  WebViewClient* Client() override { return client_; }
 
-  WebSpellCheckClient* SpellCheckClient() { return spell_check_client_; }
+  WebSpellCheckClient* SpellCheckClient() override {
+    return spell_check_client_;
+  }
 
   // Returns the page object associated with this view. This may be null when
   // the page is shutting down, but will be valid at all other times.
-  Page* GetPage() const { return page_.Get(); }
+  Page* GetPage() const override { return page_.Get(); }
 
   WebDevToolsAgentImpl* MainFrameDevToolsAgentImpl();
 
-  DevToolsEmulator* GetDevToolsEmulator() const {
+  DevToolsEmulator* GetDevToolsEmulator() const override {
     return dev_tools_emulator_.Get();
   }
 
   // Returns the main frame associated with this view. This may be null when
   // the page is shutting down, but will be valid at all other times.
-  WebLocalFrameImpl* MainFrameImpl() const;
+  WebLocalFrameImpl* MainFrameImpl() const override;
 
   // Event related methods:
   void MouseContextMenu(const WebMouseEvent&);
   void MouseDoubleClick(const WebMouseEvent&);
 
   bool StartPageScaleAnimation(const IntPoint& target_position,
                                bool use_anchor,
                                float new_scale,
                                double duration_in_seconds);
 
   // WebGestureCurveTarget implementation for fling.
   bool ScrollBy(const WebFloatSize& delta,
                 const WebFloatSize& velocity) override;
 
   // Handles context menu events orignated via the the keyboard. These
   // include the VK_APPS virtual key and the Shift+F10 combine. Code is
   // based on the Webkit function bool WebView::handleContextMenuEvent(WPARAM
   // wParam, LPARAM lParam) in webkit\webkit\win\WebView.cpp. The only
   // significant change in this function is the code to convert from a
   // Keyboard event to the Right Mouse button down event.
-  WebInputEventResult SendContextMenuEvent(const WebKeyboardEvent&);
+  WebInputEventResult SendContextMenuEvent(const WebKeyboardEvent&) override;
 
-  void ShowContextMenuAtPoint(float x, float y, ContextMenuProvider*);
+  void ShowContextMenuAtPoint(float x, float y, ContextMenuProvider*) override;
 
-  void ShowContextMenuForElement(WebElement);
+  void ShowContextMenuForElement(WebElement) override;
 
   // Notifies the WebView that a load has been committed. isNewNavigation
   // will be true if a new session history item should be created for that
   // load. isNavigationWithinPage will be true if the navigation does
   // not take the user away from the current page.
-  void DidCommitLoad(bool is_new_navigation, bool is_navigation_within_page);
+  void DidCommitLoad(bool is_new_navigation,
+                     bool is_navigation_within_page) override;
 
   void PostLayoutResize(WebLocalFrameImpl* webframe);
 
   // Indicates two things:
   //   1) This view may have a new layout now.
   //   2) Calling updateAllLifecyclePhases() is a no-op.
   // After calling WebWidget::updateAllLifecyclePhases(), expect to get this
   // notification unless the view did not need a layout.
   void LayoutUpdated(WebLocalFrameImpl*);
 
-  void DidChangeContentsSize();
-  void PageScaleFactorChanged();
-  void MainFrameScrollOffsetChanged();
+  void DidChangeContentsSize() override;
+  void PageScaleFactorChanged() override;
+  void MainFrameScrollOffsetChanged() override;
 
   // Returns true if popup menus should be rendered by the browser, false if
   // they should be rendered by WebKit (which is the default).
   static bool UseExternalPopupMenus();
 
-  bool ShouldAutoResize() const { return should_auto_resize_; }
+  bool ShouldAutoResize() const override { return should_auto_resize_; }
 
-  IntSize MinAutoSize() const { return min_auto_size_; }
+  IntSize MinAutoSize() const override { return min_auto_size_; }
 
-  IntSize MaxAutoSize() const { return max_auto_size_; }
+  IntSize MaxAutoSize() const override { return max_auto_size_; }
 
-  void UpdateMainFrameLayoutSize();
+  void UpdateMainFrameLayoutSize() override;
   void UpdatePageDefinedViewportConstraints(const ViewportDescription&);
 
   PagePopup* OpenPagePopup(PagePopupClient*);
   void ClosePagePopup(PagePopup*);
   void CleanupPagePopup();
   LocalDOMWindow* PagePopupWindow() const;
 
   // Returns the input event we're currently processing. This is used in some
   // cases where the WebCore DOM event doesn't have the information we need.
   static const WebInputEvent* CurrentInputEvent() {
     return current_input_event_;
   }
 
   GraphicsLayer* RootGraphicsLayer();
   void RegisterViewportLayersWithCompositor();
   PaintLayerCompositor* Compositor() const;
-  CompositorAnimationTimeline* LinkHighlightsTimeline() const {
+  CompositorAnimationTimeline* LinkHighlightsTimeline() const override {
     return link_highlights_timeline_.get();
   }
 
   WebViewScheduler* Scheduler() const override;
   void SetVisibilityState(WebPageVisibilityState, bool) override;
 
   bool HasOpenedPopup() const { return page_popup_.Get(); }
 
   // Called by a full frame plugin inside this view to inform it that its
   // zoom level has been updated.  The plugin should only call this function
@@ skipping 48 matching lines @@
   // Exposed for testing purposes.
   bool HasHorizontalScrollbar();
   bool HasVerticalScrollbar();
 
   // Exposed for tests.
   unsigned NumLinkHighlights() { return link_highlights_.size(); }
   LinkHighlightImpl* GetLinkHighlight(int i) {
     return link_highlights_[i].get();
   }
 
-  WebSettingsImpl* SettingsImpl();
+  WebSettingsImpl* SettingsImpl() override;
 
   // Returns the bounding box of the block type node touched by the WebPoint.
   WebRect ComputeBlockBound(const WebPoint&, bool ignore_clipping);
 
-  WebLayerTreeView* LayerTreeView() const { return layer_tree_view_; }
+  WebLayerTreeView* LayerTreeView() const override { return layer_tree_view_; }
   CompositorAnimationHost* AnimationHost() const {
     return animation_host_.get();
   }
 
   bool MatchesHeuristicsForGpuRasterizationForTesting() const {
     return matches_heuristics_for_gpu_rasterization_;
   }
 
   void UpdateBrowserControlsState(WebBrowserControlsState constraint,
                                   WebBrowserControlsState current,
                                   bool animate) override;
 
   BrowserControls& GetBrowserControls();
   // Called anytime browser controls layout height or content offset have
   // changed.
   void DidUpdateBrowserControls();
 
   void ForceNextWebGLContextCreationToFail() override;
   void ForceNextDrawingBufferCreationToFail() override;
 
   CompositorWorkerProxyClient* CreateCompositorWorkerProxyClient();
   AnimationWorkletProxyClient* CreateAnimationWorkletProxyClient();
 
-  IntSize MainFrameSize();
-  WebDisplayMode DisplayMode() const { return display_mode_; }
+  IntSize MainFrameSize() override;
+  WebDisplayMode DisplayMode() const override { return display_mode_; }
 
-  PageScaleConstraintsSet& GetPageScaleConstraintsSet() const;
+  PageScaleConstraintsSet& GetPageScaleConstraintsSet() const override;
 
   FloatSize ElasticOverscroll() const { return elastic_overscroll_; }
 
   double LastFrameTimeMonotonic() const { return last_frame_time_monotonic_; }
 
   ChromeClientImpl& ChromeClient() const { return *chrome_client_impl_.Get(); }
 
   // Returns the currently active WebInputMethodController which is the one
   // corresponding to the focused frame. It will return nullptr if there is no
   // focused frame, or if the there is one but it belongs to a different local
   // root.
   WebInputMethodControllerImpl* GetActiveWebInputMethodController() const;
 
-  void SetLastHiddenPagePopup(WebPagePopupImpl* page_popup) {
+  void SetLastHiddenPagePopup(WebPagePopupImpl* page_popup) override {
     last_hidden_page_popup_ = page_popup;
   }
 
  private:
   InspectorOverlayAgent* GetInspectorOverlay();
 
   void SetPageScaleFactorAndLocation(float, const FloatPoint&);
   void PropagateZoomFactorToLocalFrameRoots(Frame*, float);
 
   void ScrollAndRescaleViewports(float scale_factor,
@@ skipping 228 matching lines @@
   Persistent<ResizeViewportAnchor> resize_viewport_anchor_;
 };
 
 // We have no ways to check if the specified WebView is an instance of
 // WebViewImpl because WebViewImpl is the only implementation of WebView.
 DEFINE_TYPE_CASTS(WebViewImpl, WebView, webView, true, true);
 
 }  // namespace blink
 
 #endif