Changeset 101758 in webkit


Ignore:
Timestamp:
Dec 2, 2011 12:55:48 AM (12 years ago)
Author:
commit-queue@webkit.org
Message:

[Chromium] Support adding/removing page overlay to WebView
​https://bugs.webkit.org/show_bug.cgi?id=73235

Patch by Xiyuan Xia <​xiyuan@chromium.org> on 2011-12-02
Reviewed by James Robinson.

  • WebKit.gyp:
  • public/WebPageOverlay.h: Added.

(WebKit::WebPageOverlay::~WebPageOverlay):

  • public/WebView.h:
  • src/PageOverlay.cpp:

(WebKit::PageOverlay::create):
(WebKit::PageOverlay::PageOverlay):
(WebKit::OverlayGraphicsLayerClientImpl::create):
(WebKit::OverlayGraphicsLayerClientImpl::paintContents):
(WebKit::OverlayGraphicsLayerClientImpl::OverlayGraphicsLayerClientImpl):
(WebKit::PageOverlay::update):
(WebKit::PageOverlay::paintWebFrame):
(WebKit::PageOverlay::invalidateWebFrame):

  • src/PageOverlay.h:

(WebKit::PageOverlay::overlay):
(WebKit::PageOverlay::setOverlay):
(WebKit::PageOverlay::zOrder):
(WebKit::PageOverlay::setZOrder):

  • src/PageOverlayList.cpp: Added.

(WebKit::PageOverlayList::create):
(WebKit::PageOverlayList::PageOverlayList):
(WebKit::PageOverlayList::~PageOverlayList):
(WebKit::PageOverlayList::add):
(WebKit::PageOverlayList::remove):
(WebKit::PageOverlayList::update):
(WebKit::PageOverlayList::paintWebFrame):
(WebKit::PageOverlayList::find):

  • src/PageOverlayList.h: Added.

(WebKit::PageOverlayList::empty):

  • src/WebDevToolsAgentImpl.cpp:

(WebKit::WebDevToolsAgentImpl::paintPageOverlay):
(WebKit::WebDevToolsAgentImpl::highlight):
(WebKit::WebDevToolsAgentImpl::hideHighlight):

  • src/WebDevToolsAgentImpl.h:
  • src/WebFrameImpl.cpp:

(WebKit::WebFrameImpl::paintWithContext):

  • src/WebViewImpl.cpp:

(WebKit::WebViewImpl::composite):
(WebKit::WebViewImpl::addPageOverlay):
(WebKit::WebViewImpl::removePageOverlay):
(WebKit::WebViewImpl::setIsAcceleratedCompositingActive):
(WebKit::WebViewImpl::didRecreateGraphicsContext):

  • src/WebViewImpl.h:

(WebKit::WebViewImpl::pageOverlays):

Location:
trunk/Source/WebKit/chromium
Files:
1 added
10 edited
2 copied

Legend:

Unmodified
Added
Removed

  • trunk/Source/WebKit/chromium/ChangeLog

    r101709 r101758  
     12011-12-02  Xiyuan Xia  <xiyuan@chromium.org>
     2
     3        [Chromium] Support adding/removing page overlay to WebView
     4        https://bugs.webkit.org/show_bug.cgi?id=73235
     5
     6        Reviewed by James Robinson.
     7
     8        * WebKit.gyp:
     9        * public/WebPageOverlay.h: Added.
     10        (WebKit::WebPageOverlay::~WebPageOverlay):
     11        * public/WebView.h:
     12        * src/PageOverlay.cpp:
     13        (WebKit::PageOverlay::create):
     14        (WebKit::PageOverlay::PageOverlay):
     15        (WebKit::OverlayGraphicsLayerClientImpl::create):
     16        (WebKit::OverlayGraphicsLayerClientImpl::paintContents):
     17        (WebKit::OverlayGraphicsLayerClientImpl::OverlayGraphicsLayerClientImpl):
     18        (WebKit::PageOverlay::update):
     19        (WebKit::PageOverlay::paintWebFrame):
     20        (WebKit::PageOverlay::invalidateWebFrame):
     21        * src/PageOverlay.h:
     22        (WebKit::PageOverlay::overlay):
     23        (WebKit::PageOverlay::setOverlay):
     24        (WebKit::PageOverlay::zOrder):
     25        (WebKit::PageOverlay::setZOrder):
     26        * src/PageOverlayList.cpp: Added.
     27        (WebKit::PageOverlayList::create):
     28        (WebKit::PageOverlayList::PageOverlayList):
     29        (WebKit::PageOverlayList::~PageOverlayList):
     30        (WebKit::PageOverlayList::add):
     31        (WebKit::PageOverlayList::remove):
     32        (WebKit::PageOverlayList::update):
     33        (WebKit::PageOverlayList::paintWebFrame):
     34        (WebKit::PageOverlayList::find):
     35        * src/PageOverlayList.h: Added.
     36        (WebKit::PageOverlayList::empty):
     37        * src/WebDevToolsAgentImpl.cpp:
     38        (WebKit::WebDevToolsAgentImpl::paintPageOverlay):
     39        (WebKit::WebDevToolsAgentImpl::highlight):
     40        (WebKit::WebDevToolsAgentImpl::hideHighlight):
     41        * src/WebDevToolsAgentImpl.h:
     42        * src/WebFrameImpl.cpp:
     43        (WebKit::WebFrameImpl::paintWithContext):
     44        * src/WebViewImpl.cpp:
     45        (WebKit::WebViewImpl::composite):
     46        (WebKit::WebViewImpl::addPageOverlay):
     47        (WebKit::WebViewImpl::removePageOverlay):
     48        (WebKit::WebViewImpl::setIsAcceleratedCompositingActive):
     49        (WebKit::WebViewImpl::didRecreateGraphicsContext):
     50        * src/WebViewImpl.h:
     51        (WebKit::WebViewImpl::pageOverlays):
     52
    1532011-12-01  Jochen Eisinger  <jochen@chromium.org>
    254

  • trunk/Source/WebKit/chromium/WebKit.gyp

    r101576 r101758  
    261261                'public/WebNotificationPermissionCallback.h',
    262262                'public/WebOptionElement.h',
     263                'public/WebPageOverlay.h',
    263264                'public/WebPageSerializer.h',
    264265                'public/WebPageSerializerClient.h',
    … …  
    438439                'src/PageOverlay.cpp',
    439440                'src/PageOverlay.h',
     441                'src/PageOverlayList.cpp',
     442                'src/PageOverlayList.h',
    440443                'src/PlatformMessagePortChannel.cpp',
    441444                'src/PlatformMessagePortChannel.h',

  • trunk/Source/WebKit/chromium/public/WebPageOverlay.h

    r101757 r101758  
    2727 */
    2828
    29 #ifndef PageOverlay_h
    30 #define PageOverlay_h
     29#ifndef WebPageOverlay_h
     30#define WebPageOverlay_h
    3131
    32 #include <wtf/OwnPtr.h>
    33 #include <wtf/PassOwnPtr.h>
    34 
    35 namespace WebCore {
    36 class GraphicsContext;
    37 class GraphicsLayer;
    38 class GraphicsLayerClient;
    39 }
     32#include "WebCanvas.h"
     33#include "WebRect.h"
    4034
    4135namespace WebKit {
    42 class WebViewImpl;
    4336
    44 class PageOverlay {
     37class WebPageOverlay {
    4538public:
    46     class PageOverlayClient {
    47     public:
    48         virtual void paintPageOverlay(WebCore::GraphicsContext&) = 0;
    49     };
     39    // Paints page overlay contents.
     40    virtual void paintPageOverlay(WebCanvas*) = 0;
    5041
    51     static PassOwnPtr<PageOverlay> create(WebViewImpl*, PageOverlayClient*);
    52 
    53     ~PageOverlay() { }
    54 
    55     void setClient(PageOverlayClient* client) { m_client = client; }
    56 
    57     void clear();
    58     void update();
    59     void paintWebFrame(WebCore::GraphicsContext&);
    60 
    61 private:
    62     PageOverlay(WebViewImpl*, PageOverlayClient*);
    63     void invalidateWebFrame();
    64 
    65     WebViewImpl* m_viewImpl;
    66     PageOverlayClient* m_client;
    67     OwnPtr<WebCore::GraphicsLayer> m_layer;
    68     OwnPtr<WebCore::GraphicsLayerClient> m_layerClient;
     42protected:
     43    virtual ~WebPageOverlay() { }
    6944};
    7045
    7146} // namespace WebKit
    7247
    73 #endif // PageOverlay_h
     48#endif // WebPageOverlay_h

  • trunk/Source/WebKit/chromium/public/WebView.h

    r101122 r101758  
    4949class WebGraphicsContext3D;
    5050class WebNode;
     51class WebPageOverlay;
    5152class WebPermissionClient;
    5253class WebSettings;
    … …  
    410411                                    bool isInitialState) { }
    411412
     413    // PageOverlay ----------------------------------------------------------
     414
     415    // Adds/removes page overlay to this WebView. These functions change the
     416    // graphical appearance of the WebView. WebPageOverlay paints the
     417    // contents of the page overlay. It also provides an z-order number for
     418    // the page overlay. The z-order number defines the paint order the page
     419    // overlays. Page overlays with larger z-order number will be painted after
     420    // page overlays with smaller z-order number. That is, they appear above
     421    // the page overlays with smaller z-order number. If two page overlays have
     422    // the same z-order number, the later added one will be on top.
     423    virtual void addPageOverlay(WebPageOverlay*, int /*z-order*/) = 0;
     424    virtual void removePageOverlay(WebPageOverlay*) = 0;
    412425
    413426    // Testing functionality for LayoutTestController -----------------------

  • trunk/Source/WebKit/chromium/src/PageOverlay.cpp

    r100839 r101758  
    3333#include "GraphicsLayerClient.h"
    3434#include "Page.h"
     35#include "PlatformContextSkia.h"
    3536#include "Settings.h"
     37#include "WebPageOverlay.h"
    3638#include "WebViewClient.h"
    3739#include "WebViewImpl.h"
    … …  
    4143namespace WebKit {
    4244
    43 PassOwnPtr<PageOverlay> PageOverlay::create(WebViewImpl* viewImpl, PageOverlayClient* client)
     45namespace {
     46
     47WebCanvas* ToWebCanvas(GraphicsContext* gc)
    4448{
    45     return adoptPtr(new PageOverlay(viewImpl, client));
     49#if WEBKIT_USING_SKIA
     50    return gc->platformContext()->canvas();
     51#elif WEBKIT_USING_CG
     52    return gc->platformContext();
     53#endif
    4654}
    4755
    48 PageOverlay::PageOverlay(WebViewImpl* viewImpl, PageOverlayClient* client)
     56} // namespace
     57
     58PassOwnPtr<PageOverlay> PageOverlay::create(WebViewImpl* viewImpl, WebPageOverlay* overlay)
     59{
     60    return adoptPtr(new PageOverlay(viewImpl, overlay));
     61}
     62
     63PageOverlay::PageOverlay(WebViewImpl* viewImpl, WebPageOverlay* overlay)
    4964    : m_viewImpl(viewImpl)
    50     , m_client(client)
     65    , m_overlay(overlay)
     66    , m_zOrder(0)
    5167{
    5268}
    … …  
    5571class OverlayGraphicsLayerClientImpl : public WebCore::GraphicsLayerClient {
    5672public:
    57     static PassOwnPtr<OverlayGraphicsLayerClientImpl*> create(WebViewImpl* webViewImpl, PageOverlay::PageOverlayClient* pageOverlayClient)
     73    static PassOwnPtr<OverlayGraphicsLayerClientImpl*> create(WebViewImpl* webViewImpl, WebPageOverlay* overlay)
    5874    {
    59         return adoptPtr(new OverlayGraphicsLayerClientImpl(webViewImpl, pageOverlayClient));
     75        return adoptPtr(new OverlayGraphicsLayerClientImpl(webViewImpl, overlay));
    6076    }
    6177
    … …  
    6682    virtual void notifySyncRequired(const GraphicsLayer*) { }
    6783
    68     virtual void paintContents(const GraphicsLayer*, GraphicsContext& context, GraphicsLayerPaintingPhase, const IntRect& inClip)
     84    virtual void paintContents(const GraphicsLayer*, GraphicsContext& gc, GraphicsLayerPaintingPhase, const IntRect& inClip)
    6985    {
    70         m_pageOverlayClient->paintPageOverlay(context);
     86        gc.save();
     87        m_overlay->paintPageOverlay(ToWebCanvas(&gc));
     88        gc.restore();
    7189    }
    7290
    … …  
    92110
    93111private:
    94     explicit OverlayGraphicsLayerClientImpl(WebViewImpl* webViewImpl, PageOverlay::PageOverlayClient* pageOverlayClient)
    95         : m_pageOverlayClient(pageOverlayClient)
     112    OverlayGraphicsLayerClientImpl(WebViewImpl* webViewImpl, WebPageOverlay* overlay)
     113        : m_overlay(overlay)
    96114        , m_webViewImpl(webViewImpl)
    97115    {
    98116    }
    99117
    100     PageOverlay::PageOverlayClient* m_pageOverlayClient;
     118    WebPageOverlay* m_overlay;
    101119    WebViewImpl* m_webViewImpl;
    102120};
    … …  
    122140#if USE(ACCELERATED_COMPOSITING)
    123141    if (!m_layer) {
    124         m_layerClient = OverlayGraphicsLayerClientImpl::create(m_viewImpl, m_client);
     142        m_layerClient = OverlayGraphicsLayerClientImpl::create(m_viewImpl, m_overlay);
    125143        m_layer = GraphicsLayer::create(m_layerClient.get());
    126144        m_layer->setName("WebViewImpl page overlay content");
    127145        m_layer->setDrawsContent(true);
    128         const WebSize& size = m_viewImpl->size();
    129         m_layer->setSize(IntSize(size.width, size.height));
    130146    }
     147
     148    FloatSize size(m_viewImpl->size());
     149    if (size != m_layer->size()) {
     150        // Triggers re-adding to root layer to ensure that we are on top of
     151        // scrollbars.
     152        m_layer->removeFromParent();
     153        m_layer->setSize(size);
     154    }
     155
    131156    m_viewImpl->setOverlayLayer(m_layer.get());
    132157    m_layer->setNeedsDisplay();
    … …  
    136161void PageOverlay::paintWebFrame(GraphicsContext& gc)
    137162{
    138     if (!m_viewImpl->isAcceleratedCompositingActive())
    139         m_client->paintPageOverlay(gc);
     163    if (!m_viewImpl->isAcceleratedCompositingActive()) {
     164        gc.save();
     165        m_overlay->paintPageOverlay(ToWebCanvas(&gc));
     166        gc.restore();
     167    }
    140168}
    141169
    142170void PageOverlay::invalidateWebFrame()
    143171{
    144     // PageOverlayClient does the actual painting of the overlay.
     172    // WebPageOverlay does the actual painting of the overlay.
    145173    // Here we just make sure to invalidate.
    146174    if (!m_viewImpl->isAcceleratedCompositingActive()) {

  • trunk/Source/WebKit/chromium/src/PageOverlay.h

    r95901 r101758  
    4040
    4141namespace WebKit {
     42class WebPageOverlay;
    4243class WebViewImpl;
     44struct WebRect;
    4345
    4446class PageOverlay {
    4547public:
    46     class PageOverlayClient {
    47     public:
    48         virtual void paintPageOverlay(WebCore::GraphicsContext&) = 0;
    49     };
    50 
    51     static PassOwnPtr<PageOverlay> create(WebViewImpl*, PageOverlayClient*);
     48    static PassOwnPtr<PageOverlay> create(WebViewImpl*, WebPageOverlay*);
    5249
    5350    ~PageOverlay() { }
    5451
    55     void setClient(PageOverlayClient* client) { m_client = client; }
     52    WebPageOverlay* overlay() const { return m_overlay; }
     53    void setOverlay(WebPageOverlay* overlay) { m_overlay = overlay; }
     54
     55    int zOrder() const { return m_zOrder; }
     56    void setZOrder(int zOrder) { m_zOrder = zOrder; }
    5657
    5758    void clear();
    … …  
    6061
    6162private:
    62     PageOverlay(WebViewImpl*, PageOverlayClient*);
     63    PageOverlay(WebViewImpl*, WebPageOverlay*);
    6364    void invalidateWebFrame();
    6465
    6566    WebViewImpl* m_viewImpl;
    66     PageOverlayClient* m_client;
     67    WebPageOverlay* m_overlay;
    6768    OwnPtr<WebCore::GraphicsLayer> m_layer;
    6869    OwnPtr<WebCore::GraphicsLayerClient> m_layerClient;
     70    int m_zOrder;
    6971};
    7072

  • trunk/Source/WebKit/chromium/src/PageOverlayList.h

    r101757 r101758  
    2727 */
    2828
    29 #ifndef PageOverlay_h
    30 #define PageOverlay_h
     29#ifndef PageOverlayList_h
     30#define PageOverlayList_h
    3131
    3232#include <wtf/OwnPtr.h>
    3333#include <wtf/PassOwnPtr.h>
     34#include <wtf/Vector.h>
    3435
    3536namespace WebCore {
    3637class GraphicsContext;
    37 class GraphicsLayer;
    38 class GraphicsLayerClient;
    3938}
    4039
    4140namespace WebKit {
     41class PageOverlay;
     42class WebPageOverlay;
    4243class WebViewImpl;
    4344
    44 class PageOverlay {
     45class PageOverlayList {
    4546public:
    46     class PageOverlayClient {
    47     public:
    48         virtual void paintPageOverlay(WebCore::GraphicsContext&) = 0;
    49     };
     47    static PassOwnPtr<PageOverlayList> create(WebViewImpl*);
    5048
    51     static PassOwnPtr<PageOverlay> create(WebViewImpl*, PageOverlayClient*);
     49    ~PageOverlayList();
    5250
    53     ~PageOverlay() { }
     51    bool empty() const { return !m_pageOverlays.size(); }
    5452
    55     void setClient(PageOverlayClient* client) { m_client = client; }
     53    // Adds/removes a PageOverlay for given client.
     54    // Returns true if a PageOverlay is added/removed.
     55    bool add(WebPageOverlay*, int /* zOrder */);
     56    bool remove(WebPageOverlay*);
    5657
    57     void clear();
    5858    void update();
    5959    void paintWebFrame(WebCore::GraphicsContext&);
    6060
    6161private:
    62     PageOverlay(WebViewImpl*, PageOverlayClient*);
    63     void invalidateWebFrame();
     62    typedef Vector<OwnPtr<PageOverlay>, 2> PageOverlays;
     63
     64    explicit PageOverlayList(WebViewImpl*);
     65
     66    // Returns the index of the client found. Otherwise, returns WTF::notFound.
     67    size_t find(WebPageOverlay*);
    6468
    6569    WebViewImpl* m_viewImpl;
    66     PageOverlayClient* m_client;
    67     OwnPtr<WebCore::GraphicsLayer> m_layer;
    68     OwnPtr<WebCore::GraphicsLayerClient> m_layerClient;
     70    PageOverlays m_pageOverlays;
    6971};
    7072
    7173} // namespace WebKit
    7274
    73 #endif // PageOverlay_h
     75#endif // PageOverlayList_h

  • trunk/Source/WebKit/chromium/src/WebDevToolsAgentImpl.cpp

    r101469 r101758  
    4343#include "Page.h"
    4444#include "PageGroup.h"
    45 #include "PageOverlay.h"
    4645#include "PageScriptDebugServer.h"
     46#include "painting/GraphicsContextBuilder.h"
    4747#include "PlatformString.h"
    4848#include "ResourceError.h"
    … …  
    273273}
    274274
    275 // PageOverlayClient
    276 void WebDevToolsAgentImpl::paintPageOverlay(GraphicsContext& gc)
     275// WebPageOverlay
     276void WebDevToolsAgentImpl::paintPageOverlay(WebCanvas* canvas)
    277277{
    278278    InspectorController* ic = inspectorController();
    279279    if (ic)
    280         ic->drawHighlight(gc);
     280        ic->drawHighlight(GraphicsContextBuilder(canvas).context());
    281281}
    282282
    283283void WebDevToolsAgentImpl::highlight()
    284284{
    285     m_webViewImpl->setPageOverlayClient(this);
     285    // Use 99 as a big z-order number so that highlight is above other overlays.
     286    m_webViewImpl->addPageOverlay(this, 99);
    286287}
    287288
    288289void WebDevToolsAgentImpl::hideHighlight()
    289290{
    290     m_webViewImpl->setPageOverlayClient(0);
     291    m_webViewImpl->removePageOverlay(this);
    291292}
    292293

  • trunk/Source/WebKit/chromium/src/WebDevToolsAgentImpl.h

    r101231 r101758  
    3434#include "InspectorClient.h"
    3535
    36 #include "PageOverlay.h"
    3736#include "WebDevToolsAgentPrivate.h"
     37#include "WebPageOverlay.h"
    3838
    3939#include <wtf/Forward.h>
    … …  
    6363class WebDevToolsAgentImpl : public WebDevToolsAgentPrivate,
    6464                             public WebCore::InspectorClient,
    65                              public PageOverlay::PageOverlayClient {
     65                             public WebPageOverlay {
    6666public:
    6767    WebDevToolsAgentImpl(WebViewImpl* webViewImpl, WebDevToolsAgentClient* client);
    … …  
    9898    int hostId() { return m_hostId; }
    9999
    100     // PageOverlayClient
    101     virtual void paintPageOverlay(WebCore::GraphicsContext&);
     100    // WebPageOverlay
     101    virtual void paintPageOverlay(WebCanvas*);
    102102
    103103private:

  • trunk/Source/WebKit/chromium/src/WebFrameImpl.cpp

    r101706 r101758  
    20642064        gc.clip(dirtyRect);
    20652065        frameView()->paint(&gc, dirtyRect);
    2066         if (viewImpl()->pageOverlay())
    2067             viewImpl()->pageOverlay()->paintWebFrame(gc);
     2066        if (viewImpl()->pageOverlays())
     2067            viewImpl()->pageOverlays()->paintWebFrame(gc);
    20682068    } else
    20692069        gc.fillRect(dirtyRect, Color::white, ColorSpaceDeviceRGB);

  • trunk/Source/WebKit/chromium/src/WebViewImpl.cpp

    r101576 r101758  
    12571257            return;
    12581258
    1259         if (m_pageOverlay)
    1260             m_pageOverlay->update();
     1259        if (m_pageOverlays)
     1260            m_pageOverlays->update();
    12611261
    12621262        m_layerTreeHost->composite();
    … …  
    26112611}
    26122612
    2613 void WebViewImpl::setPageOverlayClient(PageOverlay::PageOverlayClient* pageOverlayClient)
    2614 {
    2615     if (pageOverlayClient) {
    2616         if (!m_pageOverlay)
    2617             m_pageOverlay = PageOverlay::create(this, pageOverlayClient);
    2618         else
    2619             m_pageOverlay->setClient(pageOverlayClient);
    2620         m_pageOverlay->update();
     2613void WebViewImpl::addPageOverlay(WebPageOverlay* overlay, int zOrder)
     2614{
     2615    if (!m_pageOverlays)
     2616        m_pageOverlays = PageOverlayList::create(this);
     2617
     2618    m_pageOverlays->add(overlay, zOrder);
     2619    setRootLayerNeedsDisplay();
     2620}
     2621
     2622void WebViewImpl::removePageOverlay(WebPageOverlay* overlay)
     2623{
     2624    if (m_pageOverlays && m_pageOverlays->remove(overlay)) {
    26212625        setRootLayerNeedsDisplay();
    2622     } else {
    2623         if (m_pageOverlay) {
    2624             m_pageOverlay->clear();
    2625             m_pageOverlay = nullptr;
    2626             setRootLayerNeedsDisplay();
    2627         }
     2626
     2627        if (m_pageOverlays->empty())
     2628            m_pageOverlays = nullptr;
    26282629    }
    26292630}
    … …  
    28712872            m_isAcceleratedCompositingActive = true;
    28722873            m_compositorCreationFailed = false;
    2873             if (m_pageOverlay)
    2874                 m_pageOverlay->update();
     2874            if (m_pageOverlays)
     2875                m_pageOverlays->update();
    28752876        } else {
    28762877            m_layerTreeHost.clear();
    … …  
    29532954    }
    29542955
    2955     if (m_pageOverlay)
    2956         m_pageOverlay->update();
     2956    if (m_pageOverlays)
     2957        m_pageOverlays->update();
    29572958}
    29582959

  • trunk/Source/WebKit/chromium/src/WebViewImpl.h

    r101553 r101758  
    4848#include "IntRect.h"
    4949#include "NotificationPresenterImpl.h"
    50 #include "PageOverlay.h"
     50#include "PageOverlayList.h"
    5151#include "UserMediaClientImpl.h"
    5252#include "cc/CCLayerTreeHost.h"
    … …  
    228228                                    unsigned inactiveForegroundColor);
    229229    virtual void performCustomContextMenuAction(unsigned action);
     230    virtual void addPageOverlay(WebPageOverlay*, int /* zOrder */);
     231    virtual void removePageOverlay(WebPageOverlay*);
    230232
    231233    // CCLayerTreeHostClient
    … …  
    243245    WebDevToolsAgentPrivate* devToolsAgentPrivate() { return m_devToolsAgent.get(); }
    244246
    245     PageOverlay* pageOverlay() const { return m_pageOverlay.get(); }
    246     void setPageOverlayClient(PageOverlay::PageOverlayClient*);
     247    PageOverlayList* pageOverlays() const { return m_pageOverlays.get(); }
    247248
    248249    void setOverlayLayer(WebCore::GraphicsLayer*);
    … …  
    580581
    581582    OwnPtr<WebDevToolsAgentPrivate> m_devToolsAgent;
    582     OwnPtr<PageOverlay> m_pageOverlay;
     583    OwnPtr<PageOverlayList> m_pageOverlays;
    583584
    584585    // Whether the webview is rendering transparently.
Note: See TracChangeset for help on using the changeset viewer.