Switch the inheritance of WebView from WebWidget to protected.

third_party/WebKit/public/web/WebView.h

 /*
  * Copyright (C) 2009, 2010, 2011, 2012 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 51 matching lines @@
 class WebViewClient;
 class WebViewScheduler;
 struct WebActiveWheelFlingParameters;
 struct WebDeviceEmulationParams;
 struct WebFloatPoint;
 struct WebMediaPlayerAction;
 struct WebPluginAction;
 struct WebPoint;
 struct WebWindowFeatures;
 
-class WebView : public WebWidget {
+class WebView : protected WebWidget {
 public:
     BLINK_EXPORT static const double textSizeMultiplierRatio;
     BLINK_EXPORT static const double minTextSizeMultiplier;
     BLINK_EXPORT static const double maxTextSizeMultiplier;
 
     enum StyleInjectionTarget {
         InjectStyleInAllFrames,
         InjectStyleInTopFrameOnly
     };
 
+    // WebWidget overrides.
+    void close() override {}

[dcheng, 2016/05/03 09:27:13]

I didn't think of this for the WebWidgetClient/WebViewClient split, but can we
just:

using WebWidget::close;
using WebWidget size;

etc?

Instead of having to duplicate the default definitions.

[lfg, 2016/05/03 21:19:43]

That does work, but it has the disadvantage of not being able to specify
specific functions in the case of multiple overrides, and the compiler also
silently ignores the using keyword if the function is redefined. I'm ok with it
either way.

[dcheng, 2016/05/04 04:55:29]

I'm OK with it either way. I don't think it's a big deal if there's multiple
overrides, since we should probably convert them together to minimize the
confusion anyway.

+    WebSize size() override { return WebSize(); }
+    void resize(const WebSize&) override {}
+    void resizeVisualViewport(const WebSize&) override {}
+    void didEnterFullScreen() override {}
+    void didExitFullScreen() override {}
+    void beginFrame(double lastFrameTimeMonotonic) override {}
+    void updateAllLifecyclePhases() override {}
+    void paint(WebCanvas*, const WebRect& viewPort) override {}
+    void paintIgnoringCompositing(WebCanvas*, const WebRect&) override {}
+    void layoutAndPaintAsync(WebLayoutAndPaintAsyncCallback*) override {}
+    void compositeAndReadbackAsync(WebCompositeAndReadbackAsyncCallback*) override {}
+    void themeChanged() override {}
+    WebInputEventResult handleInputEvent(const WebInputEvent&) override { return WebInputEventResult::NotHandled; }
+    void setCursorVisibilityState(bool isVisible) override {}
+    bool hasTouchEventHandlersAt(const WebPoint&) override { return true; }
+    void applyViewportDeltas(
+        const WebFloatSize& visualViewportDelta,
+        const WebFloatSize& layoutViewportDelta,
+        const WebFloatSize& elasticOverscrollDelta,
+        float scaleFactor,
+        float topControlsShownRatioDelta) override {}
+    void mouseCaptureLost() override {}
+    void setFocus(bool) override {}
+    bool setComposition(
+        const WebString& text,
+        const WebVector<WebCompositionUnderline>& underlines,
+        int selectionStart,
+        int selectionEnd) override
+    {
+        return false;
+    }
+    bool confirmComposition() override { return false; }
+    bool confirmComposition(ConfirmCompositionBehavior selectionBehavior) override { return false; }
+    bool confirmComposition(const WebString& text) override { return false; }
+    bool compositionRange(size_t* location, size_t* length) override { return false; }
+    WebTextInputInfo textInputInfo() override { return WebTextInputInfo(); }
+    WebTextInputType textInputType() override { return WebTextInputTypeNone; }
+    bool selectionBounds(WebRect& anchor, WebRect& focus) const override { return false; }
+    bool selectionTextDirection(WebTextDirection& start, WebTextDirection& end) const override { return false; }
+    bool isSelectionAnchorFirst() const override { return false; }
+    bool caretOrSelectionRange(size_t* location, size_t* length) override { return false; }
+    void setTextDirection(WebTextDirection) override {}
+    bool isAcceleratedCompositingActive() const override { return false; }
+    bool isWebView() const override { return false; }
+    bool isPagePopup() const override { return false; }
+    void willCloseLayerTreeView() override {}
+    void didAcquirePointerLock() override {}
+    void didNotAcquirePointerLock() override {}
+    void didLosePointerLock() override {}
+    void didChangeWindowResizerRect() override {}
+    WebColor backgroundColor() const override { return 0xFFFFFFFF; /* SK_ColorWHITE */ }
+    WebPagePopup* pagePopup() const override { return 0; }
+    void updateTopControlsState(WebTopControlsState constraints, WebTopControlsState current, bool animate) override {}
 
     // Initialization ------------------------------------------------------
 
     // Creates a WebView that is NOT yet initialized. You will need to
     // call setMainFrame to finish the initialization. It is valid
     // to pass a null client pointer.
     BLINK_EXPORT static WebView* create(WebViewClient*);
 
     // After creating a WebView, you should immediately call this method.
     // You can optionally modify the settings before calling this method.
@@ skipping 388 matching lines @@
     // Testing functionality for TestRunner ---------------------------------
 
     // Force the webgl context to fail so that webglcontextcreationerror
     // event gets generated/tested.
     virtual void forceNextWebGLContextCreationToFail() = 0;
 
     // Force the drawing buffer used by webgl contexts to fail so that the webgl
     // context's ability to deal with that failure gracefully can be tested.
     virtual void forceNextDrawingBufferCreationToFail() = 0;
 
+    // TODO(lfg): Remove this once the refactor of WebView/WebWidget is
+    // completed.
+    WebWidget* widget() { return this; }
+
 protected:
     ~WebView() {}
 };
 
 } // namespace blink
 
 #endif