Change all test cases to use WebViewBase instead of 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 84 matching lines @@
 class WebSettingsImpl;
 class WebViewScheduler;
 
 class WEB_EXPORT WebViewImpl final
     : NON_EXPORTED_BASE(public WebViewBase),
       NON_EXPORTED_BASE(public WebGestureCurveTarget),
       public PageWidgetEventHandler,
       public WebScheduler::InterventionReporter,
       public WebViewScheduler::WebViewSchedulerSettings {
  public:
-  static WebViewImpl* Create(WebViewClient*, WebPageVisibilityState);
+  static WebViewBase* Create(WebViewClient*, WebPageVisibilityState);
 
   // WebWidget methods:
   void Close() override;
   WebSize Size() override;
   void Resize(const WebSize&) override;
   void ResizeVisualViewport(const WebSize&) override;
   void DidEnterFullscreen() override;
   void DidExitFullscreen() override;
 
   void SetSuppressFrameRequestsWorkaroundFor704763Only(bool) override;
@@ skipping 152 matching lines @@
   void InvalidateRect(const IntRect&) override;
 
   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;
+  TransformationMatrix GetDeviceEmulationTransformForTesting() const override;
 
   Color BaseBackgroundColor() const override;
   bool BackgroundColorOverrideEnabled() const override {
     return background_color_override_enabled_;
   }
   WebColor BackgroundColorOverride() const override {
     return background_color_override_;
   }
 
   Frame* FocusedCoreFrame() const override;
 
   // Returns the currently focused Element or null if no element has focus.
-  Element* FocusedElement() const;
+  Element* FocusedElement() const override;
 
-  static WebViewImpl* FromPage(Page*);
+  static WebViewBase* FromPage(Page*);
 
   WebViewClient* Client() override { return 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 override { return page_.Get(); }
@@ skipping 69 matching lines @@
   PagePopup* OpenPagePopup(PagePopupClient*) override;
   void ClosePagePopup(PagePopup*) override;
   void CleanupPagePopup() override;
   LocalDOMWindow* PagePopupWindow() const override;
 
   // 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_;
   }
+  static void SetCurrentInputEventForTest(const WebInputEvent* event) {
+    current_input_event_ = event;
+  }
 
   GraphicsLayer* RootGraphicsLayer() override;
   void RegisterViewportLayersWithCompositor() override;
   PaintLayerCompositor* Compositor() const override;
   CompositorAnimationTimeline* LinkHighlightsTimeline() const override {
     return link_highlights_timeline_.get();
   }
 
   WebViewScheduler* Scheduler() const override;
   void SetVisibilityState(WebPageVisibilityState, bool) override;
 
   bool HasOpenedPopup() const override { 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
   // if the zoom change was triggered by the browser, it's only needed in case
   // a plugin can update its own zoom, say because of its own UI.
   void FullFramePluginZoomLevelChanged(double zoom_level);
 
   void ComputeScaleAndScrollForBlockRect(
       const WebPoint& hit_point,
       const WebRect& block_rect,
       float padding,
       float default_scale_when_already_legible,
       float& scale,
-      WebPoint& scroll);
-  Node* BestTapNode(const GestureEventWithHitTestResults& targeted_tap_event);
+      WebPoint& scroll) override;
+  Node* BestTapNode(
+      const GestureEventWithHitTestResults& targeted_tap_event) override;
   void EnableTapHighlightAtPoint(
-      const GestureEventWithHitTestResults& targeted_tap_event);
-  void EnableTapHighlights(HeapVector<Member<Node>>&);
+      const GestureEventWithHitTestResults& targeted_tap_event) override;
+  void EnableTapHighlights(HeapVector<Member<Node>>&) override;
   void ComputeScaleAndScrollForFocusedNode(Node* focused_node,
                                            bool zoom_in_to_legible_scale,
                                            float& scale,
                                            IntPoint& scroll,
-                                           bool& need_animation);
+                                           bool& need_animation) override;
 
-  void AnimateDoubleTapZoom(const IntPoint&);
+  void AnimateDoubleTapZoom(const IntPoint&) override;
 
   void ResolveTapDisambiguation(double timestamp_seconds,
                                 WebPoint tap_viewport_offset,
                                 bool is_long_press) override;
 
-  void EnableFakePageScaleAnimationForTesting(bool);
-  bool FakeDoubleTapAnimationPendingForTesting() const {
+  void EnableFakePageScaleAnimationForTesting(bool) override;
+  bool FakeDoubleTapAnimationPendingForTesting() const override {
     return double_tap_zoom_pending_;
   }
-  IntPoint FakePageScaleAnimationTargetPositionForTesting() const {
+  IntPoint FakePageScaleAnimationTargetPositionForTesting() const override {
     return fake_page_scale_animation_target_position_;
   }
-  float FakePageScaleAnimationPageScaleForTesting() const {
+  float FakePageScaleAnimationPageScaleForTesting() const override {
     return fake_page_scale_animation_page_scale_factor_;
   }
-  bool FakePageScaleAnimationUseAnchorForTesting() const {
+  bool FakePageScaleAnimationUseAnchorForTesting() const override {
     return fake_page_scale_animation_use_anchor_;
   }
 
   void EnterFullscreen(LocalFrame&) override;
   void ExitFullscreen(LocalFrame&) override;
   void FullscreenElementChanged(Element*, Element*) override;
 
   // Exposed for the purpose of overriding device metrics.
   void SendResizeEventAndRepaint();
 
   // Exposed for testing purposes.
-  bool HasHorizontalScrollbar();
-  bool HasVerticalScrollbar();
+  bool HasHorizontalScrollbar() override;
+  bool HasVerticalScrollbar() override;
 
   // Exposed for tests.
-  unsigned NumLinkHighlights() { return link_highlights_.size(); }
-  LinkHighlightImpl* GetLinkHighlight(int i) {
+  unsigned NumLinkHighlights() override { return link_highlights_.size(); }
+  LinkHighlightImpl* GetLinkHighlight(int i) override {
     return link_highlights_[i].get();
   }
 
   WebSettingsImpl* SettingsImpl() override;
 
   // Returns the bounding box of the block type node touched by the WebPoint.
-  WebRect ComputeBlockBound(const WebPoint&, bool ignore_clipping);
+  WebRect ComputeBlockBound(const WebPoint&, bool ignore_clipping) override;
 
   WebLayerTreeView* LayerTreeView() const override { return layer_tree_view_; }
   CompositorAnimationHost* AnimationHost() const override {
     return animation_host_.get();
   }
 
-  bool MatchesHeuristicsForGpuRasterizationForTesting() const {
+  bool MatchesHeuristicsForGpuRasterizationForTesting() const override {
     return matches_heuristics_for_gpu_rasterization_;
   }
 
   void UpdateBrowserControlsState(WebBrowserControlsState constraint,
                                   WebBrowserControlsState current,
                                   bool animate) override;
 
-  BrowserControls& GetBrowserControls();
+  BrowserControls& GetBrowserControls() override;
   // Called anytime browser controls layout height or content offset have
   // changed.
   void DidUpdateBrowserControls() override;
 
   void ForceNextWebGLContextCreationToFail() override;
   void ForceNextDrawingBufferCreationToFail() override;
 
   CompositorWorkerProxyClient* CreateCompositorWorkerProxyClient() override;
   AnimationWorkletProxyClient* CreateAnimationWorkletProxyClient() override;
 
@@ skipping 47 matching lines @@
 
   // TODO(lfg): Remove once WebViewFrameWidget is deleted.
   void ScheduleAnimationForWidget() override;
   bool GetCompositionCharacterBounds(WebVector<WebRect>&) override;
 
   void UpdateBaseBackgroundColor();
 
   friend class WebView;  // So WebView::Create can call our constructor
   friend class WebViewFrameWidget;
   friend class WTF::RefCounted<WebViewImpl>;
-  friend void SetCurrentInputEventForTest(const WebInputEvent*);
 
   explicit WebViewImpl(WebViewClient*, WebPageVisibilityState);
   ~WebViewImpl() override;
 
   void HideSelectPopup();
 
   HitTestResult HitTestResultForRootFramePos(const IntPoint&);
   HitTestResult HitTestResultForViewportPos(const IntPoint&);
 
   void ConfigureAutoResizeMode();
@@ skipping 193 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