Diff
Modified: trunk/Source/WebKit/chromium/ChangeLog (92810 => 92811)
--- trunk/Source/WebKit/chromium/ChangeLog 2011-08-11 01:08:42 UTC (rev 92810)
+++ trunk/Source/WebKit/chromium/ChangeLog 2011-08-11 01:17:16 UTC (rev 92811)
@@ -1,3 +1,75 @@
+2011-08-10 John Abd-El-Malek <[email protected]>
+
+ [chromium] Update WebScrollbar so that it works with overlay scrollbars on Lion
+ https://bugs.webkit.org/show_bug.cgi?id=66008
+
+ Reviewed by James Robinson.
+
+ * WebKit.gyp:
+ * public/WebScrollbar.h:
+ * public/WebScrollbarClient.h:
+ * src/ScrollbarGroup.cpp: Added.
+ (WebKit::ScrollbarGroup::ScrollbarGroup):
+ (WebKit::ScrollbarGroup::~ScrollbarGroup):
+ (WebKit::ScrollbarGroup::scrollbarCreated):
+ (WebKit::ScrollbarGroup::scrollbarDestroyed):
+ (WebKit::ScrollbarGroup::setLastMousePosition):
+ (WebKit::ScrollbarGroup::scrollSize):
+ (WebKit::ScrollbarGroup::scrollPosition):
+ (WebKit::ScrollbarGroup::setScrollOffset):
+ (WebKit::ScrollbarGroup::invalidateScrollbarRect):
+ (WebKit::ScrollbarGroup::invalidateScrollCornerRect):
+ (WebKit::ScrollbarGroup::isActive):
+ (WebKit::ScrollbarGroup::enclosingScrollableArea):
+ (WebKit::ScrollbarGroup::isScrollCornerVisible):
+ (WebKit::ScrollbarGroup::getTickmarks):
+ (WebKit::ScrollbarGroup::convertFromContainingViewToScrollbar):
+ (WebKit::ScrollbarGroup::horizontalScrollbar):
+ (WebKit::ScrollbarGroup::verticalScrollbar):
+ (WebKit::ScrollbarGroup::minimumScrollPosition):
+ (WebKit::ScrollbarGroup::maximumScrollPosition):
+ (WebKit::ScrollbarGroup::visibleHeight):
+ (WebKit::ScrollbarGroup::visibleWidth):
+ (WebKit::ScrollbarGroup::contentsSize):
+ (WebKit::ScrollbarGroup::overhangAmount):
+ (WebKit::ScrollbarGroup::currentMousePosition):
+ (WebKit::ScrollbarGroup::shouldSuspendScrollAnimations):
+ (WebKit::ScrollbarGroup::scrollbarStyleChanged):
+ (WebKit::ScrollbarGroup::isOnActivePage):
+ (WebKit::ScrollbarGroup::disconnectFromPage):
+ * src/ScrollbarGroup.h: Added.
+ (WebKit::ScrollbarGroup::scrollCornerRect):
+ * src/WebPluginContainerImpl.cpp:
+ (WebKit::WebPluginContainerImpl::paint):
+ (WebKit::WebPluginContainerImpl::reportGeometry):
+ (WebKit::WebPluginContainerImpl::scrollbarGroup):
+ (WebKit::WebPluginContainerImpl::willStartLiveResize):
+ (WebKit::WebPluginContainerImpl::willEndLiveResize):
+ (WebKit::WebPluginContainerImpl::handleMouseEvent):
+ * src/WebPluginContainerImpl.h:
+ * src/WebScrollbarImpl.cpp:
+ (WebKit::WebScrollbar::createForPlugin):
+ (WebKit::WebScrollbarImpl::WebScrollbarImpl):
+ (WebKit::WebScrollbarImpl::~WebScrollbarImpl):
+ (WebKit::WebScrollbarImpl::setScrollOffset):
+ (WebKit::WebScrollbarImpl::invalidateScrollbarRect):
+ (WebKit::WebScrollbarImpl::getTickmarks):
+ (WebKit::WebScrollbarImpl::convertFromContainingViewToScrollbar):
+ (WebKit::WebScrollbarImpl::scrollbarStyleChanged):
+ (WebKit::WebScrollbarImpl::isOverlay):
+ (WebKit::WebScrollbarImpl::setValue):
+ (WebKit::WebScrollbarImpl::scroll):
+ (WebKit::WebScrollbarImpl::onMouseMove):
+ (WebKit::WebScrollbarImpl::onMouseLeave):
+ (WebKit::WebScrollbarImpl::onMouseWheel):
+ (WebKit::WebScrollbarImpl::onKeyDown):
+ * src/WebScrollbarImpl.h:
+ (WebKit::WebScrollbarImpl::scrollOffset):
+ (WebKit::WebScrollbarImpl::scrollbar):
+ * src/WebViewImpl.cpp:
+ (WebKit::WebViewImpl::willStartLiveResize):
+ (WebKit::WebViewImpl::willEndLiveResize):
+
2011-08-10 Dmitry Lomov <[email protected]>
[Chromium] Decouple implementation of allowFileSystem, openFileSystem and allowDatabase from WebWorkerBase.
Modified: trunk/Source/WebKit/chromium/DEPS (92810 => 92811)
--- trunk/Source/WebKit/chromium/DEPS 2011-08-11 01:08:42 UTC (rev 92810)
+++ trunk/Source/WebKit/chromium/DEPS 2011-08-11 01:17:16 UTC (rev 92811)
@@ -32,7 +32,7 @@
vars = {
'chromium_svn': 'http://src.chromium.org/svn/trunk/src',
- 'chromium_rev': '96009'
+ 'chromium_rev': '96244'
}
deps = {
Modified: trunk/Source/WebKit/chromium/WebKit.gyp (92810 => 92811)
--- trunk/Source/WebKit/chromium/WebKit.gyp 2011-08-11 01:08:42 UTC (rev 92810)
+++ trunk/Source/WebKit/chromium/WebKit.gyp 2011-08-11 01:17:16 UTC (rev 92811)
@@ -398,6 +398,8 @@
'src/PlatformMessagePortChannel.cpp',
'src/PlatformMessagePortChannel.h',
'src/ResourceHandle.cpp',
+ 'src/ScrollbarGroup.cpp',
+ 'src/ScrollbarGroup.h',
'src/SharedWorkerRepository.cpp',
'src/SocketStreamHandle.cpp',
'src/SpeechInputClientImpl.cpp',
Modified: trunk/Source/WebKit/chromium/public/WebScrollbar.h (92810 => 92811)
--- trunk/Source/WebKit/chromium/public/WebScrollbar.h 2011-08-11 01:08:42 UTC (rev 92810)
+++ trunk/Source/WebKit/chromium/public/WebScrollbar.h 2011-08-11 01:17:16 UTC (rev 92811)
@@ -34,9 +34,13 @@
#include "WebCanvas.h"
#include "WebCommon.h"
+// TODO(jam): take this out once Chrome rolls this revision of WebKit.
+#define WEBSCROLLBAR_SUPPORTS_OVERLAY
+
namespace WebKit {
class WebInputEvent;
+class WebPluginContainer;
class WebScrollbarClient;
struct WebRect;
@@ -59,14 +63,20 @@
ScrollByPixel
};
- // Creates a WebScrollbar.
- WEBKIT_EXPORT static WebScrollbar* create(WebScrollbarClient*, Orientation);
+ // Creates a WebScrollbar for use by a plugin. The plugin container and
+ // client are guaranteed to outlive this object.
+ WEBKIT_EXPORT static WebScrollbar* createForPlugin(Orientation,
+ WebPluginContainer*,
+ WebScrollbarClient*);
virtual ~WebScrollbar() {}
// Gets the thickness of the scrollbar in pixels.
WEBKIT_EXPORT static int defaultThickness();
+ // Return true if this is an overlay scrollbar.
+ virtual bool isOverlay() const = 0;
+
// Sets the rectangle of the scrollbar.
virtual void setLocation(const WebRect&) = 0;
Modified: trunk/Source/WebKit/chromium/public/WebScrollbarClient.h (92810 => 92811)
--- trunk/Source/WebKit/chromium/public/WebScrollbarClient.h 2011-08-11 01:08:42 UTC (rev 92810)
+++ trunk/Source/WebKit/chromium/public/WebScrollbarClient.h 2011-08-11 01:17:16 UTC (rev 92811)
@@ -40,6 +40,7 @@
class WebScrollbarClient {
public:
virtual void valueChanged(WebScrollbar*) = 0;
+ virtual void overlayChanged(WebScrollbar*) = 0;
virtual void invalidateScrollbarRect(WebScrollbar*, const WebRect&) = 0;
virtual void getTickmarks(WebScrollbar*, WebVector<WebRect>*) const = 0;
};
Added: trunk/Source/WebKit/chromium/src/ScrollbarGroup.cpp (0 => 92811)
--- trunk/Source/WebKit/chromium/src/ScrollbarGroup.cpp (rev 0)
+++ trunk/Source/WebKit/chromium/src/ScrollbarGroup.cpp 2011-08-11 01:17:16 UTC (rev 92811)
@@ -0,0 +1,254 @@
+/*
+ * Copyright (C) 2011 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:
+ *
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY APPLE AND ITS CONTRIBUTORS "AS IS" AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL APPLE OR ITS CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, 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 "config.h"
+#include "ScrollbarGroup.h"
+
+#include "Page.h"
+#include "Scrollbar.h"
+#include "ScrollbarTheme.h"
+#include "WebRect.h"
+#include "WebScrollbarImpl.h"
+
+using namespace WebCore;
+
+namespace WebKit {
+
+ScrollbarGroup::ScrollbarGroup(Page* page)
+ : m_page(page)
+ , m_horizontalScrollbar(0)
+ , m_verticalScrollbar(0)
+{
+ m_page->addScrollableArea(this);
+}
+
+ScrollbarGroup::~ScrollbarGroup()
+{
+ ASSERT(!m_horizontalScrollbar);
+ ASSERT(!m_verticalScrollbar);
+ if (m_page)
+ m_page->removeScrollableArea(this);
+}
+
+void ScrollbarGroup::scrollbarCreated(WebScrollbarImpl* scrollbar)
+{
+ if (scrollbar->scrollbar()->orientation() == HorizontalScrollbar) {
+ ASSERT(!m_horizontalScrollbar);
+ m_horizontalScrollbar = scrollbar;
+ didAddHorizontalScrollbar(scrollbar->scrollbar());
+ } else {
+ ASSERT(!m_verticalScrollbar);
+ m_verticalScrollbar = scrollbar;
+ didAddVerticalScrollbar(scrollbar->scrollbar());
+ }
+}
+
+void ScrollbarGroup::scrollbarDestroyed(WebScrollbarImpl* scrollbar)
+{
+ if (scrollbar == m_horizontalScrollbar) {
+ willRemoveHorizontalScrollbar(scrollbar->scrollbar());
+ m_horizontalScrollbar = 0;
+ } else {
+ ASSERT(scrollbar == m_verticalScrollbar);
+ willRemoveVerticalScrollbar(scrollbar->scrollbar());
+ m_verticalScrollbar = 0;
+ }
+}
+
+void ScrollbarGroup::setLastMousePosition(const IntPoint& point)
+{
+ m_lastMousePosition = point;
+}
+
+int ScrollbarGroup::scrollSize(WebCore::ScrollbarOrientation orientation) const
+{
+ WebScrollbarImpl* webScrollbar = orientation == HorizontalScrollbar ? m_horizontalScrollbar : m_verticalScrollbar;
+ if (!webScrollbar)
+ return 0;
+ Scrollbar* scrollbar = webScrollbar->scrollbar();
+ return scrollbar->totalSize() - scrollbar->visibleSize();
+}
+
+int ScrollbarGroup::scrollPosition(Scrollbar* scrollbar) const
+{
+ WebScrollbarImpl* webScrollbar = scrollbar->orientation() == HorizontalScrollbar ? m_horizontalScrollbar : m_verticalScrollbar;
+ if (!webScrollbar)
+ return 0;
+ return webScrollbar->scrollOffset();
+}
+
+void ScrollbarGroup::setScrollOffset(const IntPoint& offset)
+{
+ if (m_horizontalScrollbar && m_horizontalScrollbar->scrollOffset() != offset.x())
+ m_horizontalScrollbar->setScrollOffset(offset.x());
+ else if (m_verticalScrollbar && m_verticalScrollbar->scrollOffset() != offset.y())
+ m_verticalScrollbar->setScrollOffset(offset.y());
+}
+
+void ScrollbarGroup::invalidateScrollbarRect(Scrollbar* scrollbar, const IntRect& rect)
+{
+ if (m_horizontalScrollbar && scrollbar == m_horizontalScrollbar->scrollbar())
+ m_horizontalScrollbar->invalidateScrollbarRect(rect);
+ else if (m_verticalScrollbar && scrollbar == m_verticalScrollbar->scrollbar())
+ m_verticalScrollbar->invalidateScrollbarRect(rect);
+}
+
+void ScrollbarGroup::invalidateScrollCornerRect(const IntRect&)
+{
+}
+
+bool ScrollbarGroup::isActive() const
+{
+ return true;
+}
+
+ScrollableArea* ScrollbarGroup::enclosingScrollableArea() const
+{
+ // FIXME: Return a parent scrollable area that can be scrolled.
+ return 0;
+}
+
+bool ScrollbarGroup::isScrollCornerVisible() const
+{
+ return false;
+}
+
+void ScrollbarGroup::getTickmarks(Vector<IntRect>& tickmarks) const
+{
+ if (m_verticalScrollbar)
+ m_verticalScrollbar->getTickmarks(tickmarks);
+}
+
+IntPoint ScrollbarGroup::convertFromContainingViewToScrollbar(const Scrollbar* scrollbar, const IntPoint& parentPoint) const
+{
+ if (m_horizontalScrollbar && scrollbar == m_horizontalScrollbar->scrollbar())
+ return m_horizontalScrollbar->convertFromContainingViewToScrollbar(parentPoint);
+ if (m_verticalScrollbar && scrollbar == m_verticalScrollbar->scrollbar())
+ return m_verticalScrollbar->convertFromContainingViewToScrollbar(parentPoint);
+ WEBKIT_ASSERT_NOT_REACHED();
+ return IntPoint();
+}
+
+Scrollbar* ScrollbarGroup::horizontalScrollbar() const
+{
+ return m_horizontalScrollbar ? m_horizontalScrollbar->scrollbar() : 0;
+}
+
+Scrollbar* ScrollbarGroup::verticalScrollbar() const
+{
+ return m_verticalScrollbar ? m_verticalScrollbar->scrollbar() : 0;
+}
+
+IntPoint ScrollbarGroup::scrollPosition() const
+{
+ int x = m_horizontalScrollbar ? m_horizontalScrollbar->scrollOffset() : 0;
+ int y = m_verticalScrollbar ? m_verticalScrollbar->scrollOffset() : 0;
+ return IntPoint(x, y);
+}
+
+IntPoint ScrollbarGroup::minimumScrollPosition() const
+{
+ return IntPoint();
+}
+
+IntPoint ScrollbarGroup::maximumScrollPosition() const
+{
+ return IntPoint(contentsSize().width() - visibleWidth(), contentsSize().height() - visibleHeight());
+}
+
+int ScrollbarGroup::visibleHeight() const
+{
+ if (m_verticalScrollbar)
+ return m_verticalScrollbar->scrollbar()->height();
+ if (m_horizontalScrollbar)
+ return m_horizontalScrollbar->scrollbar()->height();
+ WEBKIT_ASSERT_NOT_REACHED();
+ return 0;
+}
+
+int ScrollbarGroup::visibleWidth() const
+{
+ if (m_horizontalScrollbar)
+ return m_horizontalScrollbar->scrollbar()->width();
+ if (m_verticalScrollbar)
+ return m_verticalScrollbar->scrollbar()->width();
+ WEBKIT_ASSERT_NOT_REACHED();
+ return 0;
+}
+
+IntSize ScrollbarGroup::contentsSize() const
+{
+ IntSize size;
+ if (m_horizontalScrollbar)
+ size.setWidth(m_horizontalScrollbar->scrollbar()->totalSize());
+ else if (m_verticalScrollbar) {
+ size.setWidth(m_verticalScrollbar->scrollbar()->x());
+ if (m_verticalScrollbar->scrollbar()->isOverlayScrollbar())
+ size.expand(WebScrollbar::defaultThickness(), 0);
+ }
+ if (m_verticalScrollbar)
+ size.setHeight(m_verticalScrollbar->scrollbar()->totalSize());
+ else if (m_horizontalScrollbar) {
+ size.setHeight(m_horizontalScrollbar->scrollbar()->y());
+ if (m_horizontalScrollbar->scrollbar()->isOverlayScrollbar())
+ size.expand(0, WebScrollbar::defaultThickness());
+ }
+ return size;
+}
+
+IntSize ScrollbarGroup::overhangAmount() const
+{
+ return IntSize();
+}
+
+IntPoint ScrollbarGroup::currentMousePosition() const
+{
+ return m_lastMousePosition;
+}
+
+bool ScrollbarGroup::shouldSuspendScrollAnimations() const
+{
+ return false;
+}
+
+void ScrollbarGroup::scrollbarStyleChanged()
+{
+ if (m_horizontalScrollbar)
+ m_horizontalScrollbar->scrollbarStyleChanged();
+ if (m_verticalScrollbar)
+ m_verticalScrollbar->scrollbarStyleChanged();
+}
+
+bool ScrollbarGroup::isOnActivePage() const
+{
+ return true;
+}
+
+void ScrollbarGroup::disconnectFromPage()
+{
+ m_page = 0;
+}
+
+} // namespace WebKit
Added: trunk/Source/WebKit/chromium/src/ScrollbarGroup.h (0 => 92811)
--- trunk/Source/WebKit/chromium/src/ScrollbarGroup.h (rev 0)
+++ trunk/Source/WebKit/chromium/src/ScrollbarGroup.h 2011-08-11 01:17:16 UTC (rev 92811)
@@ -0,0 +1,86 @@
+/*
+ * Copyright (C) 2011 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:
+ *
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY APPLE AND ITS CONTRIBUTORS "AS IS" AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL APPLE OR ITS CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, 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 ScrollbarGroup_h
+#define ScrollbarGroup_h
+
+#include "ScrollableArea.h"
+
+#include <wtf/RefPtr.h>
+
+namespace WebCore {
+class Page;
+}
+
+namespace WebKit {
+
+class WebScrollbarImpl;
+
+class ScrollbarGroup : public WebCore::ScrollableArea {
+public:
+ explicit ScrollbarGroup(WebCore::Page*);
+ ~ScrollbarGroup();
+
+ void scrollbarCreated(WebScrollbarImpl*);
+ void scrollbarDestroyed(WebScrollbarImpl*);
+ void setLastMousePosition(const WebCore::IntPoint&);
+
+ // WebCore::ScrollableArea methods
+ virtual int scrollSize(WebCore::ScrollbarOrientation) const;
+ virtual int scrollPosition(WebCore::Scrollbar*) const;
+ virtual void setScrollOffset(const WebCore::IntPoint&);
+ virtual void invalidateScrollbarRect(WebCore::Scrollbar*, const WebCore::IntRect&);
+ virtual void invalidateScrollCornerRect(const WebCore::IntRect&);
+ virtual bool isActive() const;
+ virtual ScrollableArea* enclosingScrollableArea() const;
+ virtual WebCore::IntRect scrollCornerRect() const { return WebCore::IntRect(); }
+ virtual bool isScrollCornerVisible() const;
+ virtual void getTickmarks(Vector<WebCore::IntRect>&) const;
+ virtual WebCore::IntPoint convertFromContainingViewToScrollbar(const WebCore::Scrollbar*, const WebCore::IntPoint& parentPoint) const;
+ virtual WebCore::Scrollbar* horizontalScrollbar() const;
+ virtual WebCore::Scrollbar* verticalScrollbar() const;
+ virtual WebCore::IntPoint scrollPosition() const;
+ virtual WebCore::IntPoint minimumScrollPosition() const;
+ virtual WebCore::IntPoint maximumScrollPosition() const;
+ virtual int visibleHeight() const;
+ virtual int visibleWidth() const;
+ virtual WebCore::IntSize contentsSize() const;
+ virtual WebCore::IntSize overhangAmount() const;
+ virtual WebCore::IntPoint currentMousePosition() const;
+ virtual bool shouldSuspendScrollAnimations() const;
+ virtual void scrollbarStyleChanged();
+ virtual bool isOnActivePage() const;
+ virtual void disconnectFromPage();
+
+private:
+ WebCore::Page* m_page;
+ WebCore::IntPoint m_lastMousePosition;
+ WebScrollbarImpl* m_horizontalScrollbar;
+ WebScrollbarImpl* m_verticalScrollbar;
+};
+
+} // namespace WebKit
+
+#endif
Modified: trunk/Source/WebKit/chromium/src/WebPluginContainerImpl.cpp (92810 => 92811)
--- trunk/Source/WebKit/chromium/src/WebPluginContainerImpl.cpp 2011-08-11 01:08:42 UTC (rev 92810)
+++ trunk/Source/WebKit/chromium/src/WebPluginContainerImpl.cpp 2011-08-11 01:17:16 UTC (rev 92811)
@@ -34,6 +34,7 @@
#include "Chrome.h"
#include "ChromeClientImpl.h"
#include "PluginLayerChromium.h"
+#include "ScrollbarGroup.h"
#include "WebClipboard.h"
#include "WebCursorInfo.h"
#include "WebDataSourceImpl.h"
@@ -69,7 +70,9 @@
#include "MouseEvent.h"
#include "Page.h"
#include "RenderBox.h"
+#include "ScrollAnimator.h"
#include "ScrollView.h"
+#include "ScrollbarTheme.h"
#include "UserGestureIndicator.h"
#include "WheelEvent.h"
@@ -91,6 +94,14 @@
void WebPluginContainerImpl::paint(GraphicsContext* gc, const IntRect& damageRect)
{
+ if (gc->updatingControlTints() && m_scrollbarGroup) {
+ // See comment in FrameView::updateControlTints().
+ if (m_scrollbarGroup->horizontalScrollbar())
+ m_scrollbarGroup->horizontalScrollbar()->invalidate();
+ if (m_scrollbarGroup->verticalScrollbar())
+ m_scrollbarGroup->verticalScrollbar()->invalidate();
+ }
+
if (gc->paintingDisabled())
return;
@@ -306,6 +317,9 @@
calculateGeometry(frameRect(), windowRect, clipRect, cutOutRects);
m_webPlugin->updateGeometry(windowRect, clipRect, cutOutRects, isVisible());
+
+ if (m_scrollbarGroup)
+ m_scrollbarGroup->scrollAnimator()->contentsResized();
}
void WebPluginContainerImpl::setBackingTextureId(unsigned id)
@@ -437,6 +451,26 @@
}
#endif
+
+ScrollbarGroup* WebPluginContainerImpl::scrollbarGroup()
+{
+ if (!m_scrollbarGroup)
+ m_scrollbarGroup = adoptPtr(new ScrollbarGroup(m_element->document()->frame()->page()));
+ return m_scrollbarGroup.get();
+}
+
+void WebPluginContainerImpl::willStartLiveResize()
+{
+ if (m_scrollbarGroup)
+ m_scrollbarGroup->willStartLiveResize();
+}
+
+void WebPluginContainerImpl::willEndLiveResize()
+{
+ if (m_scrollbarGroup)
+ m_scrollbarGroup->willEndLiveResize();
+}
+
// Private methods -------------------------------------------------------------
WebPluginContainerImpl::WebPluginContainerImpl(WebCore::HTMLPlugInElement* element, WebPlugin* webPlugin)
@@ -476,6 +510,18 @@
containingFrame->document()->setFocusedNode(m_element);
}
+ if (m_scrollbarGroup) {
+ // This needs to be set before the other callbacks in this scope, since
+ // the scroll animator class might query the position in response.
+ m_scrollbarGroup->setLastMousePosition(IntPoint(event->x(), event->y()));
+ if (event->type() == eventNames().mousemoveEvent)
+ m_scrollbarGroup->scrollAnimator()->mouseMovedInContentArea();
+ else if (event->type() == eventNames().mouseoverEvent)
+ m_scrollbarGroup->scrollAnimator()->mouseEnteredContentArea();
+ else if (event->type() == eventNames().mouseoutEvent)
+ m_scrollbarGroup->scrollAnimator()->mouseExitedContentArea();
+ }
+
WebCursorInfo cursorInfo;
if (m_webPlugin->handleInputEvent(webEvent, cursorInfo))
event->setDefaultHandled();
Modified: trunk/Source/WebKit/chromium/src/WebPluginContainerImpl.h (92810 => 92811)
--- trunk/Source/WebKit/chromium/src/WebPluginContainerImpl.h 2011-08-11 01:08:42 UTC (rev 92810)
+++ trunk/Source/WebKit/chromium/src/WebPluginContainerImpl.h 2011-08-11 01:17:16 UTC (rev 92811)
@@ -35,6 +35,7 @@
#include "WebPluginContainer.h"
#include "Widget.h"
+#include <wtf/OwnPtr.h>
#include <wtf/PassRefPtr.h>
#include <wtf/Vector.h>
@@ -54,6 +55,7 @@
namespace WebKit {
+class ScrollbarGroup;
class WebPlugin;
class WebPluginLoadObserver;
@@ -127,6 +129,11 @@
virtual WebCore::LayerChromium* platformLayer() const;
#endif
+ ScrollbarGroup* scrollbarGroup();
+
+ void willStartLiveResize();
+ void willEndLiveResize();
+
private:
WebPluginContainerImpl(WebCore::HTMLPlugInElement* element, WebPlugin* webPlugin);
~WebPluginContainerImpl();
@@ -150,6 +157,10 @@
#if USE(ACCELERATED_COMPOSITING)
RefPtr<WebCore::PluginLayerChromium> m_platformLayer;
#endif
+
+ // The associated scrollbar group object, created lazily. Used for Pepper
+ // scrollbars.
+ OwnPtr<ScrollbarGroup> m_scrollbarGroup;
};
} // namespace WebKit
Modified: trunk/Source/WebKit/chromium/src/WebScrollbarImpl.cpp (92810 => 92811)
--- trunk/Source/WebKit/chromium/src/WebScrollbarImpl.cpp 2011-08-11 01:08:42 UTC (rev 92810)
+++ trunk/Source/WebKit/chromium/src/WebScrollbarImpl.cpp 2011-08-11 01:17:16 UTC (rev 92811)
@@ -33,26 +33,32 @@
#include "GraphicsContext.h"
#include "KeyboardCodes.h"
-#include "painting/GraphicsContextBuilder.h"
+#include "ScrollAnimator.h"
+#include "ScrollTypes.h"
#include "Scrollbar.h"
+#include "ScrollbarGroup.h"
#include "ScrollbarTheme.h"
-#include "ScrollTypes.h"
#include "WebCanvas.h"
#include "WebInputEvent.h"
#include "WebInputEventConversion.h"
+#include "WebPluginContainerImpl.h"
#include "WebRect.h"
#include "WebScrollbarClient.h"
#include "WebVector.h"
#include "WebViewImpl.h"
+#include "painting/GraphicsContextBuilder.h"
using namespace std;
using namespace WebCore;
namespace WebKit {
-WebScrollbar* WebScrollbar::create(WebScrollbarClient* client, Orientation orientation)
+WebScrollbar* WebScrollbar::createForPlugin(Orientation orientation,
+ WebPluginContainer* pluginContainer,
+ WebScrollbarClient* client)
{
- return new WebScrollbarImpl(client, orientation);
+ WebPluginContainerImpl* plugin = static_cast<WebPluginContainerImpl*>(pluginContainer);
+ return new WebScrollbarImpl(orientation, plugin->scrollbarGroup(), client);
}
int WebScrollbar::defaultThickness()
@@ -60,20 +66,64 @@
return ScrollbarTheme::nativeTheme()->scrollbarThickness();
}
-WebScrollbarImpl::WebScrollbarImpl(WebScrollbarClient* client, Orientation orientation)
- : m_client(client)
+WebScrollbarImpl::WebScrollbarImpl(Orientation orientation,
+ ScrollbarGroup* group,
+ WebScrollbarClient* client)
+ : m_group(group)
+ , m_client(client)
, m_scrollOffset(0)
{
m_scrollbar = Scrollbar::createNativeScrollbar(
- static_cast<ScrollableArea*>(this),
+ static_cast<ScrollableArea*>(m_group),
static_cast<ScrollbarOrientation>(orientation),
RegularScrollbar);
+ m_group->scrollbarCreated(this);
}
WebScrollbarImpl::~WebScrollbarImpl()
{
+ m_group->scrollbarDestroyed(this);
}
+void WebScrollbarImpl::setScrollOffset(int scrollOffset)
+{
+ m_scrollOffset = scrollOffset;
+ m_client->valueChanged(this);
+}
+
+void WebScrollbarImpl::invalidateScrollbarRect(const IntRect& rect)
+{
+ WebRect webrect(rect);
+ webrect.x += m_scrollbar->x();
+ webrect.y += m_scrollbar->y();
+ m_client->invalidateScrollbarRect(this, webrect);
+}
+
+void WebScrollbarImpl::getTickmarks(Vector<IntRect>& tickmarks) const
+{
+ WebVector<WebRect> ticks;
+ m_client->getTickmarks(const_cast<WebScrollbarImpl*>(this), &ticks);
+ tickmarks.resize(ticks.size());
+ for (size_t i = 0; i < ticks.size(); ++i)
+ tickmarks[i] = ticks[i];
+}
+
+IntPoint WebScrollbarImpl::convertFromContainingViewToScrollbar(const IntPoint& parentPoint) const
+{
+ IntPoint offset(parentPoint.x() - m_scrollbar->x(), parentPoint.y() - m_scrollbar->y());
+ return m_scrollbar->Widget::convertFromContainingView(offset);
+}
+
+void WebScrollbarImpl::scrollbarStyleChanged()
+{
+ m_client->overlayChanged(this);
+}
+
+bool WebScrollbarImpl::isOverlay() const
+{
+ return m_scrollbar->isOverlayScrollbar();
+}
+
void WebScrollbarImpl::setLocation(const WebRect& rect)
{
IntRect oldRect = m_scrollbar->frameRect();
@@ -95,7 +145,7 @@
void WebScrollbarImpl::setValue(int position)
{
- ScrollableArea::scrollToOffsetWithoutAnimation(m_scrollbar->orientation(), static_cast<float>(position));
+ m_group->scrollToOffsetWithoutAnimation(m_scrollbar->orientation(), static_cast<float>(position));
}
void WebScrollbarImpl::setDocumentSize(int size)
@@ -114,7 +164,7 @@
else
dir = horizontal ? ScrollLeft : ScrollUp;
- WebCore::ScrollableArea::scroll(dir, static_cast<WebCore::ScrollGranularity>(granularity), multiplier);
+ m_group->scroll(dir, static_cast<WebCore::ScrollGranularity>(granularity), multiplier);
}
void WebScrollbarImpl::paint(WebCanvas* canvas, const WebRect& rect)
@@ -182,40 +232,27 @@
return m_scrollbar->mouseMoved(PlatformMouseEventBuilder(m_scrollbar.get(), mousemove));
}
- if (m_scrollbar->hoveredPart() != NoPart)
+ if (m_scrollbar->hoveredPart() != NoPart && !m_scrollbar->isOverlayScrollbar())
m_scrollbar->mouseExited();
return false;
}
bool WebScrollbarImpl::onMouseLeave(const WebInputEvent& event)
{
- if (m_scrollbar->hoveredPart() == NoPart)
- return false;
+ if (m_scrollbar->hoveredPart() != NoPart)
+ m_scrollbar->mouseExited();
- return m_scrollbar->mouseExited();
+ return false;
}
bool WebScrollbarImpl::onMouseWheel(const WebInputEvent& event)
{
- // Same logic as in Scrollview.cpp. If we can move at all, we'll accept the event.
WebMouseWheelEvent mousewheel = *static_cast<const WebMouseWheelEvent*>(&event);
- int maxScrollDelta = m_scrollbar->maximum() - m_scrollbar->value();
- float delta = m_scrollbar->orientation() == HorizontalScrollbar ? mousewheel.deltaX : mousewheel.deltaY;
- if ((delta < 0 && maxScrollDelta > 0) || (delta > 0 && m_scrollbar->value() > 0)) {
- if (mousewheel.scrollByPage) {
- ASSERT(m_scrollbar->orientation() == VerticalScrollbar);
- bool negative = delta < 0;
- delta = max(max(static_cast<float>(m_scrollbar->visibleSize()) * Scrollbar::minFractionToStepWhenPaging(), static_cast<float>(m_scrollbar->visibleSize() - Scrollbar::maxOverlapBetweenPages())), 1.0f);
- if (negative)
- delta *= -1;
- }
- ScrollableArea::scroll((m_scrollbar->orientation() == HorizontalScrollbar) ? WebCore::ScrollLeft : WebCore::ScrollUp, WebCore::ScrollByPixel, delta);
- return true;
- }
+ PlatformWheelEventBuilder platformEvent(m_scrollbar.get(), mousewheel);
+ m_group->handleWheelEvent(platformEvent);
+ return platformEvent.isAccepted();
+}
- return false;
- }
-
bool WebScrollbarImpl::onKeyDown(const WebInputEvent& event)
{
WebKeyboardEvent keyboard = *static_cast<const WebKeyboardEvent*>(&event);
@@ -248,100 +285,9 @@
WebCore::ScrollGranularity scrollGranularity;
if (WebViewImpl::mapKeyCodeForScroll(keyCode, &scrollDirection, &scrollGranularity)) {
// Will return false if scroll direction wasn't compatible with this scrollbar.
- return ScrollableArea::scroll(scrollDirection, scrollGranularity);
+ return m_group->scroll(scrollDirection, scrollGranularity);
}
return false;
}
-int WebScrollbarImpl::scrollSize(WebCore::ScrollbarOrientation orientation) const
-{
- return (orientation == m_scrollbar->orientation()) ? (m_scrollbar->totalSize() - m_scrollbar->visibleSize()) : 0;
-}
-
-int WebScrollbarImpl::scrollPosition(Scrollbar*) const
-{
- return m_scrollOffset;
-}
-
-void WebScrollbarImpl::setScrollOffset(const IntPoint& offset)
-{
- if (m_scrollbar->orientation() == HorizontalScrollbar)
- m_scrollOffset = offset.x();
- else
- m_scrollOffset = offset.y();
-
- m_client->valueChanged(this);
-}
-
-void WebScrollbarImpl::invalidateScrollbarRect(Scrollbar*, const IntRect& rect)
-{
- WebRect webrect(rect);
- webrect.x += m_scrollbar->x();
- webrect.y += m_scrollbar->y();
- m_client->invalidateScrollbarRect(this, webrect);
-}
-
-void WebScrollbarImpl::invalidateScrollCornerRect(const IntRect&)
-{
-}
-
-bool WebScrollbarImpl::isActive() const
-{
- return true;
-}
-
-ScrollableArea* WebScrollbarImpl::enclosingScrollableArea() const
-{
- // FIXME: Return a parent scrollable area that can be scrolled.
- return 0;
-}
-
-bool WebScrollbarImpl::isScrollCornerVisible() const
-{
- return false;
-}
-
-void WebScrollbarImpl::getTickmarks(Vector<IntRect>& tickmarks) const
-{
- WebVector<WebRect> ticks;
- m_client->getTickmarks(const_cast<WebScrollbarImpl*>(this), &ticks);
- tickmarks.resize(ticks.size());
- for (size_t i = 0; i < ticks.size(); ++i)
- tickmarks[i] = ticks[i];
-}
-
-Scrollbar* WebScrollbarImpl::horizontalScrollbar() const
-{
- return m_scrollbar->orientation() == HorizontalScrollbar ? m_scrollbar.get() : 0;
-}
-
-Scrollbar* WebScrollbarImpl::verticalScrollbar() const
-{
- return m_scrollbar->orientation() == VerticalScrollbar ? m_scrollbar.get() : 0;
-}
-
-int WebScrollbarImpl::visibleHeight() const
-{
- return m_scrollbar->height();
-}
-
-int WebScrollbarImpl::visibleWidth() const
-{
- return m_scrollbar->width();
-}
-
-IntSize WebScrollbarImpl::contentsSize() const
-{
- // This isn't technically correct, since we don't have the contentSize. However it's good enough
- // to make the ScrollAnimator code happy.
- int thickness = defaultThickness();
- int length = m_scrollbar->totalSize();
- return m_scrollbar->orientation() == VerticalScrollbar ? IntSize(thickness, length) : IntSize(length, thickness);
-}
-
-IntSize WebScrollbarImpl::overhangAmount() const
-{
- return IntSize();
-}
-
} // namespace WebKit
Modified: trunk/Source/WebKit/chromium/src/WebScrollbarImpl.h (92810 => 92811)
--- trunk/Source/WebKit/chromium/src/WebScrollbarImpl.h 2011-08-11 01:08:42 UTC (rev 92810)
+++ trunk/Source/WebKit/chromium/src/WebScrollbarImpl.h 2011-08-11 01:17:16 UTC (rev 92811)
@@ -31,24 +31,39 @@
#ifndef WebScrollbarImpl_h
#define WebScrollbarImpl_h
-#include "ScrollableArea.h"
#include "WebScrollbar.h"
#include <wtf/RefPtr.h>
+#include <wtf/Vector.h>
namespace WebCore {
+class IntPoint;
+class IntRect;
class Scrollbar;
}
namespace WebKit {
-class WebScrollbarImpl : public WebScrollbar,
- public WebCore::ScrollableArea {
+class ScrollbarGroup;
+
+class WebScrollbarImpl : public WebScrollbar {
public:
- WebScrollbarImpl(WebScrollbarClient*, Orientation orientation);
+ WebScrollbarImpl(Orientation,
+ ScrollbarGroup*,
+ WebScrollbarClient*);
~WebScrollbarImpl();
+ void setScrollOffset(int);
+ void invalidateScrollbarRect(const WebCore::IntRect&);
+ void getTickmarks(Vector<WebCore::IntRect>&) const;
+ WebCore::IntPoint convertFromContainingViewToScrollbar(const WebCore::IntPoint& parentPoint) const;
+ void scrollbarStyleChanged();
+
+ int scrollOffset() { return m_scrollOffset; }
+ WebCore::Scrollbar* scrollbar() { return m_scrollbar.get(); }
+
// WebKit::WebScrollbar methods
+ virtual bool isOverlay() const;
virtual void setLocation(const WebRect&);
virtual int value() const;
virtual void setValue(int position);
@@ -57,24 +72,6 @@
virtual void paint(WebCanvas*, const WebRect&);
virtual bool handleInputEvent(const WebInputEvent&);
- // WebCore::ScrollableArea methods
- virtual int scrollSize(WebCore::ScrollbarOrientation) const;
- virtual int scrollPosition(WebCore::Scrollbar*) const;
- virtual void setScrollOffset(const WebCore::IntPoint&);
- virtual void invalidateScrollbarRect(WebCore::Scrollbar*, const WebCore::IntRect&);
- virtual void invalidateScrollCornerRect(const WebCore::IntRect&);
- virtual bool isActive() const;
- virtual ScrollableArea* enclosingScrollableArea() const;
- virtual WebCore::IntRect scrollCornerRect() const { return WebCore::IntRect(); }
- virtual bool isScrollCornerVisible() const;
- virtual void getTickmarks(Vector<WebCore::IntRect>&) const;
- virtual WebCore::Scrollbar* horizontalScrollbar() const;
- virtual WebCore::Scrollbar* verticalScrollbar() const;
- virtual int visibleHeight() const;
- virtual int visibleWidth() const;
- virtual WebCore::IntSize contentsSize() const;
- virtual WebCore::IntSize overhangAmount() const;
-
private:
bool onMouseDown(const WebInputEvent& event);
bool onMouseUp(const WebInputEvent& event);
@@ -83,6 +80,7 @@
bool onMouseWheel(const WebInputEvent& event);
bool onKeyDown(const WebInputEvent& event);
+ ScrollbarGroup* m_group;
WebScrollbarClient* m_client;
int m_scrollOffset;
Modified: trunk/Source/WebKit/chromium/src/WebViewImpl.cpp (92810 => 92811)
--- trunk/Source/WebKit/chromium/src/WebViewImpl.cpp 2011-08-11 01:08:42 UTC (rev 92810)
+++ trunk/Source/WebKit/chromium/src/WebViewImpl.cpp 2011-08-11 01:17:16 UTC (rev 92811)
@@ -1008,6 +1008,11 @@
{
if (mainFrameImpl() && mainFrameImpl()->frameView())
mainFrameImpl()->frameView()->willStartLiveResize();
+
+ Frame* frame = mainFrameImpl()->frame();
+ WebPluginContainerImpl* pluginContainer = WebFrameImpl::pluginContainerFromFrame(frame);
+ if (pluginContainer)
+ pluginContainer->willStartLiveResize();
}
void WebViewImpl::resize(const WebSize& newSize)
@@ -1037,6 +1042,11 @@
{
if (mainFrameImpl() && mainFrameImpl()->frameView())
mainFrameImpl()->frameView()->willEndLiveResize();
+
+ Frame* frame = mainFrameImpl()->frame();
+ WebPluginContainerImpl* pluginContainer = WebFrameImpl::pluginContainerFromFrame(frame);
+ if (pluginContainer)
+ pluginContainer->willEndLiveResize();
}
void WebViewImpl::animate(double frameBeginTime)
