void LLWebBrowserCtrl::navigateToLocalPage( const std::string& subdir, const std::string& filename_in )
{
std::string language = LLUI::getLanguage();
std::string delim = gDirUtilp->getDirDelimiter();
std::string filename;
filename += subdir;
filename += delim;
filename += filename_in;
std::string expanded_filename = gDirUtilp->findSkinnedFilename("html", language, filename);
if (gDirUtilp->fileExists(expanded_filename))
{
navigateTo(expanded_filename);
return;
}
if (language != "en-us")
{
expanded_filename = gDirUtilp->findSkinnedFilename("html", "en-us", filename);
if (gDirUtilp->fileExists(expanded_filename))
{
navigateTo(expanded_filename);
return;
}
}
llwarns << "File " << subdir << delim << filename_in << "not found" << llendl;
}
TEST_P(CompositorWorkerTest, noProxies) {
// This case is identical to compositor-proxy-basic, but no proxies have
// actually been created.
registerMockedHttpURLLoad("compositor-proxy-plumbing-no-proxies.html");
navigateTo(m_baseURL + "compositor-proxy-plumbing-no-proxies.html");
forceFullCompositingUpdate();
Document* document = frame()->document();
Element* tallElement = document->getElementById("tall");
WebLayer* tallLayer = webLayerFromElement(tallElement);
EXPECT_TRUE(!tallLayer);
Element* proxiedElement = document->getElementById("proxied");
WebLayer* proxiedLayer = webLayerFromElement(proxiedElement);
EXPECT_TRUE(!proxiedLayer);
// Note: we presume the existance of mutable properties implies that the the
// element has a corresponding compositor proxy. Element ids (which are also
// used by animations) do not have this implication, so we do not check for
// them here.
Element* scrollElement = document->getElementById("proxied-scroller");
WebLayer* scrollLayer = scrollingWebLayerFromElement(scrollElement);
EXPECT_FALSE(!!scrollLayer->compositorMutableProperties());
WebLayer* rootScrollLayer = getRootScrollLayer();
EXPECT_FALSE(!!rootScrollLayer->compositorMutableProperties());
}
TEST_P(CompositorWorkerTest, disconnectedProxies) {
// This case is identical to compositor-proxy-basic, but the proxies are
// disconnected (the result should be the same as
// compositor-proxy-plumbing-no-proxies).
registerMockedHttpURLLoad("compositor-proxy-basic-disconnected.html");
navigateTo(m_baseURL + "compositor-proxy-basic-disconnected.html");
forceFullCompositingUpdate();
Document* document = frame()->document();
Element* tallElement = document->getElementById("tall");
WebLayer* tallLayer = webLayerFromElement(tallElement);
EXPECT_TRUE(!tallLayer);
Element* proxiedElement = document->getElementById("proxied");
WebLayer* proxiedLayer = webLayerFromElement(proxiedElement);
EXPECT_TRUE(!proxiedLayer);
Element* scrollElement = document->getElementById("proxied-scroller");
WebLayer* scrollLayer = scrollingWebLayerFromElement(scrollElement);
EXPECT_FALSE(!!scrollLayer->compositorMutableProperties());
WebLayer* rootScrollLayer = getRootScrollLayer();
EXPECT_FALSE(!!rootScrollLayer->compositorMutableProperties());
}
TEST_F(ScrollingCoordinatorTest, fastFractionalScrollingDiv)
{
registerMockedHttpURLLoad("fractional-scroll-div.html");
navigateTo(m_baseURL + "fractional-scroll-div.html");
forceFullCompositingUpdate();
Document* document = frame()->document();
Element* scrollableElement = document->getElementById("scroller");
ASSERT(scrollableElement);
scrollableElement->setScrollTop(1.0);
scrollableElement->setScrollLeft(1.0);
forceFullCompositingUpdate();
// Make sure the fractional scroll offset change 1.0 -> 1.2 gets propagated
// to compositor.
scrollableElement->setScrollTop(1.2);
scrollableElement->setScrollLeft(1.2);
forceFullCompositingUpdate();
LayoutObject* layoutObject = scrollableElement->layoutObject();
ASSERT_TRUE(layoutObject->isBox());
LayoutBox* box = toLayoutBox(layoutObject);
ASSERT_TRUE(box->usesCompositedScrolling());
CompositedLayerMapping* compositedLayerMapping = box->layer()->compositedLayerMapping();
ASSERT_TRUE(compositedLayerMapping->hasScrollingLayer());
ASSERT(compositedLayerMapping->scrollingContentsLayer());
WebLayer* webScrollLayer = compositedLayerMapping->scrollingContentsLayer()->platformLayer();
ASSERT_TRUE(webScrollLayer);
ASSERT_NEAR(1.2, webScrollLayer->scrollPositionDouble().x, 0.01);
ASSERT_NEAR(1.2, webScrollLayer->scrollPositionDouble().y, 0.01);
}
TEST_P(CompositorWorkerTest, applyingMutationsMultipleElements) {
registerMockedHttpURLLoad("compositor-proxy-basic.html");
navigateTo(m_baseURL + "compositor-proxy-basic.html");
Document* document = frame()->document();
{
forceFullCompositingUpdate();
Element* proxiedElement = document->getElementById("proxied-transform");
WebLayer* proxiedLayer = webLayerFromElement(proxiedElement);
EXPECT_TRUE(proxiedLayer->compositorMutableProperties() &
CompositorMutableProperty::kTransform);
EXPECT_FALSE(proxiedLayer->compositorMutableProperties() &
(CompositorMutableProperty::kScrollLeft |
CompositorMutableProperty::kScrollTop |
CompositorMutableProperty::kOpacity));
EXPECT_TRUE(proxiedLayer->elementId());
TransformationMatrix transformMatrix(11, 12, 13, 14, 21, 22, 23, 24, 31, 32,
33, 34, 41, 42, 43, 44);
CompositorMutation mutation;
mutation.setTransform(TransformationMatrix::toSkMatrix44(transformMatrix));
proxiedElement->updateFromCompositorMutation(mutation);
forceFullCompositingUpdate();
const String& cssValue =
document->domWindow()
->getComputedStyle(proxiedElement, String())
->getPropertyValueInternal(CSSPropertyTransform);
EXPECT_EQ(
"matrix3d(11, 12, 13, 14, 21, 22, 23, 24, 31, 32, 33, 34, 41, 42, 43, "
"44)",
cssValue);
}
{
Element* proxiedElement = document->getElementById("proxied-opacity");
WebLayer* proxiedLayer = webLayerFromElement(proxiedElement);
EXPECT_TRUE(proxiedLayer->compositorMutableProperties() &
CompositorMutableProperty::kOpacity);
EXPECT_FALSE(proxiedLayer->compositorMutableProperties() &
(CompositorMutableProperty::kScrollLeft |
CompositorMutableProperty::kScrollTop |
CompositorMutableProperty::kTransform));
EXPECT_TRUE(proxiedLayer->elementId());
CompositorMutation mutation;
mutation.setOpacity(0.5);
proxiedElement->updateFromCompositorMutation(mutation);
forceFullCompositingUpdate();
const String& cssValue = document->domWindow()
->getComputedStyle(proxiedElement, String())
->getPropertyValueInternal(CSSPropertyOpacity);
EXPECT_EQ("0.5", cssValue);
}
}
TEST_F(ScrollingCoordinatorTest, setupScrollbarLayerShouldNotCrash)
{
registerMockedHttpURLLoad("setup_scrollbar_layer_crash.html");
navigateTo(m_baseURL + "setup_scrollbar_layer_crash.html");
forceFullCompositingUpdate();
// This test document setup an iframe with scrollbars, then switch to
// an empty document by javascript.
}
TEST_F(ScrollingCoordinatorTest, scrollEventHandler)
{
registerMockedHttpURLLoad("scroll-event-handler.html");
navigateTo(m_baseURL + "scroll-event-handler.html");
forceFullCompositingUpdate();
ASSERT_TRUE(webLayerTreeView()->haveScrollEventHandlers());
}
TEST_F(ScrollingCoordinatorTest, wheelEventHandlerBoth)
{
registerMockedHttpURLLoad("wheel-event-handler-both.html");
navigateTo(m_baseURL + "wheel-event-handler-both.html");
forceFullCompositingUpdate();
ASSERT_EQ(WebEventListenerProperties::BlockingAndPassive, webLayerTreeView()->eventListenerProperties(WebEventListenerClass::MouseWheel));
}
TEST_F(ScrollingCoordinatorTest, touchEventHandlerPassive)
{
registerMockedHttpURLLoad("touch-event-handler-passive.html");
navigateTo(m_baseURL + "touch-event-handler-passive.html");
forceFullCompositingUpdate();
ASSERT_EQ(WebEventListenerProperties::Passive, webLayerTreeView()->eventListenerProperties(WebEventListenerClass::Touch));
}
TEST_F(ScrollingCoordinatorTest, clippedBodyTest)
{
registerMockedHttpURLLoad("clipped-body.html");
navigateTo(m_baseURL + "clipped-body.html");
forceFullCompositingUpdate();
WebLayer* rootScrollLayer = getRootScrollLayer();
ASSERT_EQ(0u, rootScrollLayer->nonFastScrollableRegion().size());
}
LLFloaterHtmlSimple::LLFloaterHtmlSimple(const LLSD &initial_url)
: LLFloater()
{
LLUICtrlFactory::getInstance()->buildFloater(this, "floater_html_simple.xml");
// *TODO: set browser properties?
navigateTo(initial_url.asString());
}
TEST_F(ScrollingCoordinatorTest, wheelEventHandler)
{
registerMockedHttpURLLoad("wheel-event-handler.html");
navigateTo(m_baseURL + "wheel-event-handler.html");
forceFullCompositingUpdate();
WebLayer* rootScrollLayer = getRootScrollLayer();
ASSERT_TRUE(rootScrollLayer->haveWheelEventHandlers());
}
TEST_F(ScrollingCoordinatorTest, updateEventHandlersDuringTeardown)
{
registerMockedHttpURLLoad("scroll-event-handler-window.html");
navigateTo(m_baseURL + "scroll-event-handler-window.html");
forceFullCompositingUpdate();
// Simulate detaching the document from its DOM window. This should not
// cause a crash when the WebViewImpl is closed by the test runner.
frame()->document()->detach();
}
TEST_F(ScrollingCoordinatorTest, overflowHidden)
{
registerMockedHttpURLLoad("overflow-hidden.html");
navigateTo(m_baseURL + "overflow-hidden.html");
forceFullCompositingUpdate();
// Verify the properties of the accelerated scrolling element starting from the LayoutObject
// all the way to the WebLayer.
Element* overflowElement = frame()->document()->getElementById("unscrollable-y");
ASSERT(overflowElement);
LayoutObject* layoutObject = overflowElement->layoutObject();
ASSERT_TRUE(layoutObject->isBox());
ASSERT_TRUE(layoutObject->hasLayer());
LayoutBox* box = toLayoutBox(layoutObject);
ASSERT_TRUE(box->usesCompositedScrolling());
ASSERT_EQ(PaintsIntoOwnBacking, box->layer()->compositingState());
CompositedLayerMapping* compositedLayerMapping = box->layer()->compositedLayerMapping();
ASSERT_TRUE(compositedLayerMapping->hasScrollingLayer());
ASSERT(compositedLayerMapping->scrollingContentsLayer());
GraphicsLayer* graphicsLayer = compositedLayerMapping->scrollingContentsLayer();
ASSERT_EQ(box->layer()->scrollableArea(), graphicsLayer->scrollableArea());
WebLayer* webScrollLayer = compositedLayerMapping->scrollingContentsLayer()->platformLayer();
ASSERT_TRUE(webScrollLayer->scrollable());
ASSERT_TRUE(webScrollLayer->userScrollableHorizontal());
ASSERT_FALSE(webScrollLayer->userScrollableVertical());
overflowElement = frame()->document()->getElementById("unscrollable-x");
ASSERT(overflowElement);
layoutObject = overflowElement->layoutObject();
ASSERT_TRUE(layoutObject->isBox());
ASSERT_TRUE(layoutObject->hasLayer());
box = toLayoutBox(layoutObject);
ASSERT_TRUE(box->scrollableArea()->usesCompositedScrolling());
ASSERT_EQ(PaintsIntoOwnBacking, box->layer()->compositingState());
compositedLayerMapping = box->layer()->compositedLayerMapping();
ASSERT_TRUE(compositedLayerMapping->hasScrollingLayer());
ASSERT(compositedLayerMapping->scrollingContentsLayer());
graphicsLayer = compositedLayerMapping->scrollingContentsLayer();
ASSERT_EQ(box->layer()->scrollableArea(), graphicsLayer->scrollableArea());
webScrollLayer = compositedLayerMapping->scrollingContentsLayer()->platformLayer();
ASSERT_TRUE(webScrollLayer->scrollable());
ASSERT_FALSE(webScrollLayer->userScrollableHorizontal());
ASSERT_TRUE(webScrollLayer->userScrollableVertical());
}
void LLViewerMediaImpl::createMediaSource()
{
if(! mMediaURL.empty())
{
navigateTo(mMediaURL, mMimeType, false);
}
else if(! mMimeType.empty())
{
initializeMedia(mMimeType);
}
}
int BasicMonster::doWander()
{
if (position == lastSeenPlayer) lastSeenPlayer = Point(-1,-1);
if (attitude == ATTITUDE_HOSTILE && lastSeenPlayer.x >= 0)
{
return navigateTo(lastSeenPlayer);
}
else
{
Point step = level->getRandomLocation(WALKABLE | NO_CREATURE, position, 1.5f);
float diagonal = (step.x - position.x != 0 && step.y - position.y != 0) ? std::sqrt(2.f) : 1.f;
moveTo(step);
return static_cast<int>(getWalkingSpeed() * diagonal);
}
}
TEST_F(ScrollingCoordinatorTest, fastScrollingCanBeDisabledWithSetting)
{
navigateTo("about:blank");
webViewImpl()->settings()->setThreadedScrollingEnabled(false);
forceFullCompositingUpdate();
// Make sure the scrolling coordinator is active.
FrameView* frameView = frame()->view();
Page* page = frame()->page();
ASSERT_TRUE(page->scrollingCoordinator());
ASSERT_TRUE(page->scrollingCoordinator()->coordinatesScrollingForFrameView(frameView));
// Main scrolling should be enabled with the setting override.
WebLayer* rootScrollLayer = getRootScrollLayer();
ASSERT_TRUE(rootScrollLayer->scrollable());
ASSERT_TRUE(rootScrollLayer->shouldScrollOnMainThread());
}
TEST_F(ScrollingCoordinatorTest, fractionalScrollingNonLayerFixedPosition)
{
registerMockedHttpURLLoad("fractional-scroll-fixed-position.html");
navigateTo(m_baseURL + "fractional-scroll-fixed-position.html");
// Prevent fixed-position element from getting its own layer.
webViewImpl()->settings()->setPreferCompositingToLCDTextEnabled(false);
forceFullCompositingUpdate();
FrameView* frameView = frame()->view();
frameView->scrollTo(DoublePoint(1.5, 1.5));
WebLayer* rootScrollLayer = getRootScrollLayer();
// Scroll on main if there is non-composited fixed position element.
// And the containing scroll layer should not get fractional scroll offset.
ASSERT_TRUE(rootScrollLayer->shouldScrollOnMainThread());
ASSERT_EQ(1.0, rootScrollLayer->scrollPositionDouble().x);
ASSERT_EQ(1.0, rootScrollLayer->scrollPositionDouble().y);
ASSERT_EQ(0.0, rootScrollLayer->position().x);
ASSERT_EQ(0.0, rootScrollLayer->position().y);
}
TEST_F(ScrollingCoordinatorTest, iframeScrolling)
{
registerMockedHttpURLLoad("iframe-scrolling.html");
registerMockedHttpURLLoad("iframe-scrolling-inner.html");
navigateTo(m_baseURL + "iframe-scrolling.html");
forceFullCompositingUpdate();
// Verify the properties of the accelerated scrolling element starting from the LayoutObject
// all the way to the WebLayer.
Element* scrollableFrame = frame()->document()->getElementById("scrollable");
ASSERT_TRUE(scrollableFrame);
LayoutObject* layoutObject = scrollableFrame->layoutObject();
ASSERT_TRUE(layoutObject);
ASSERT_TRUE(layoutObject->isLayoutPart());
LayoutPart* layoutPart = toLayoutPart(layoutObject);
ASSERT_TRUE(layoutPart);
ASSERT_TRUE(layoutPart->widget());
ASSERT_TRUE(layoutPart->widget()->isFrameView());
FrameView* innerFrameView = toFrameView(layoutPart->widget());
LayoutView* innerLayoutView = innerFrameView->layoutView();
ASSERT_TRUE(innerLayoutView);
PaintLayerCompositor* innerCompositor = innerLayoutView->compositor();
ASSERT_TRUE(innerCompositor->inCompositingMode());
ASSERT_TRUE(innerCompositor->scrollLayer());
GraphicsLayer* scrollLayer = innerCompositor->scrollLayer();
ASSERT_EQ(innerFrameView, scrollLayer->scrollableArea());
WebLayer* webScrollLayer = scrollLayer->platformLayer();
ASSERT_TRUE(webScrollLayer->scrollable());
#if OS(ANDROID)
// Now verify we've attached impl-side scrollbars onto the scrollbar layers
ASSERT_TRUE(innerCompositor->layerForHorizontalScrollbar());
ASSERT_TRUE(innerCompositor->layerForHorizontalScrollbar()->hasContentsLayer());
ASSERT_TRUE(innerCompositor->layerForVerticalScrollbar());
ASSERT_TRUE(innerCompositor->layerForVerticalScrollbar()->hasContentsLayer());
#endif
}
TEST_P(CompositorWorkerTest, plumbingElementIdAndMutableProperties) {
registerMockedHttpURLLoad("compositor-proxy-basic.html");
navigateTo(m_baseURL + "compositor-proxy-basic.html");
forceFullCompositingUpdate();
Document* document = frame()->document();
Element* tallElement = document->getElementById("tall");
WebLayer* tallLayer = webLayerFromElement(tallElement);
EXPECT_TRUE(!tallLayer);
Element* proxiedElement = document->getElementById("proxied-transform");
WebLayer* proxiedLayer = webLayerFromElement(proxiedElement);
EXPECT_TRUE(proxiedLayer->compositorMutableProperties() &
CompositorMutableProperty::kTransform);
EXPECT_FALSE(proxiedLayer->compositorMutableProperties() &
(CompositorMutableProperty::kScrollLeft |
CompositorMutableProperty::kScrollTop |
CompositorMutableProperty::kOpacity));
EXPECT_TRUE(proxiedLayer->elementId());
Element* scrollElement = document->getElementById("proxied-scroller");
WebLayer* scrollLayer = scrollingWebLayerFromElement(scrollElement);
EXPECT_TRUE(scrollLayer->compositorMutableProperties() &
(CompositorMutableProperty::kScrollLeft |
CompositorMutableProperty::kScrollTop));
EXPECT_FALSE(scrollLayer->compositorMutableProperties() &
(CompositorMutableProperty::kTransform |
CompositorMutableProperty::kOpacity));
EXPECT_TRUE(scrollLayer->elementId());
WebLayer* rootScrollLayer = getRootScrollLayer();
EXPECT_TRUE(rootScrollLayer->compositorMutableProperties() &
(CompositorMutableProperty::kScrollLeft |
CompositorMutableProperty::kScrollTop));
EXPECT_FALSE(rootScrollLayer->compositorMutableProperties() &
(CompositorMutableProperty::kTransform |
CompositorMutableProperty::kOpacity));
EXPECT_TRUE(rootScrollLayer->elementId());
}
void DeclarativeTabModel::updateTabUrl(int tabId, bool activeTab, const QString &url, bool navigate)
{
if (!LinkValidator::navigable(QUrl(url))) {
#if DEBUG_LOGS
qDebug() << "invalid url: " << url;
#endif
return;
}
int tabIndex = findTabIndex(tabId);
bool updateDb = false;
if (tabIndex >= 0 && (m_tabs.at(tabIndex).url() != url || activeTab)) {
QVector<int> roles;
roles << UrlRole << TitleRole << ThumbPathRole;
m_tabs[tabIndex].setUrl(url);
if (navigate) {
m_tabs[tabIndex].setNextLink(0);
int currentLinkId = m_tabs.at(tabIndex).currentLink();
m_tabs[tabIndex].setPreviousLink(currentLinkId);
m_tabs[tabIndex].setCurrentLink(nextLinkId());
}
m_tabs[tabIndex].setTitle("");
m_tabs[tabIndex].setThumbnailPath("");
if (tabId == m_activeTab.tabId()) {
m_activeTab = m_tabs[tabIndex];
}
emit dataChanged(index(tabIndex, 0), index(tabIndex, 0), roles);
updateDb = true;
}
if (updateDb) {
if (!navigate) {
updateTab(tabId, url, "", "");
} else {
navigateTo(tabId, url, "", "");
}
}
}
void CarShopMenu::on_buyButton_clicked()
{
if(!vehicle)
return;
try
{
player->buyVehicle(vehicle);
navigateToPrevious();
navigateTo("GarageMenu");
}
catch(Game::Player::InsufficientFundsException)
{
QMessageBox msgBox;
msgBox.setText("Rahasi eivät riitä autoon.");
msgBox.exec();
}
}
TEST_F(ScrollingCoordinatorTest, FixedPositionLosingBackingShouldTriggerMainThreadScroll)
{
webViewImpl()->settings()->setPreferCompositingToLCDTextEnabled(false);
registerMockedHttpURLLoad("fixed-position-losing-backing.html");
navigateTo(m_baseURL + "fixed-position-losing-backing.html");
forceFullCompositingUpdate();
WebLayer* scrollLayer = frame()->page()->deprecatedLocalMainFrame()->view()->layerForScrolling()->platformLayer();
Document* document = frame()->document();
Element* fixedPos = document->getElementById("fixed");
EXPECT_TRUE(static_cast<LayoutBoxModelObject*>(fixedPos->layoutObject())->layer()->hasCompositedLayerMapping());
EXPECT_FALSE(scrollLayer->shouldScrollOnMainThread());
fixedPos->setInlineStyleProperty(CSSPropertyTransform, CSSValueNone);
forceFullCompositingUpdate();
EXPECT_FALSE(static_cast<LayoutBoxModelObject*>(fixedPos->layoutObject())->layer()->hasCompositedLayerMapping());
EXPECT_TRUE(scrollLayer->shouldScrollOnMainThread());
}
TEST_F(ScrollingCoordinatorTest, scrollbarsForceMainThreadOrHaveWebScrollbarLayer)
{
registerMockedHttpURLLoad("trivial-scroller.html");
navigateTo(m_baseURL + "trivial-scroller.html");
forceFullCompositingUpdate();
Document* document = frame()->document();
Element* scrollableElement = document->getElementById("scroller");
ASSERT(scrollableElement);
LayoutObject* layoutObject = scrollableElement->layoutObject();
ASSERT_TRUE(layoutObject->isBox());
LayoutBox* box = toLayoutBox(layoutObject);
ASSERT_TRUE(box->usesCompositedScrolling());
CompositedLayerMapping* compositedLayerMapping = box->layer()->compositedLayerMapping();
GraphicsLayer* scrollbarGraphicsLayer = compositedLayerMapping->layerForVerticalScrollbar();
ASSERT_TRUE(scrollbarGraphicsLayer);
bool hasWebScrollbarLayer = !scrollbarGraphicsLayer->drawsContent();
ASSERT_TRUE(hasWebScrollbarLayer || scrollbarGraphicsLayer->platformLayer()->shouldScrollOnMainThread());
}
TEST_F(ScrollingCoordinatorTest, overflowScrolling)
{
registerMockedHttpURLLoad("overflow-scrolling.html");
navigateTo(m_baseURL + "overflow-scrolling.html");
forceFullCompositingUpdate();
// Verify the properties of the accelerated scrolling element starting from the LayoutObject
// all the way to the WebLayer.
Element* scrollableElement = frame()->document()->getElementById("scrollable");
ASSERT(scrollableElement);
LayoutObject* layoutObject = scrollableElement->layoutObject();
ASSERT_TRUE(layoutObject->isBox());
ASSERT_TRUE(layoutObject->hasLayer());
LayoutBox* box = toLayoutBox(layoutObject);
ASSERT_TRUE(box->usesCompositedScrolling());
ASSERT_EQ(PaintsIntoOwnBacking, box->layer()->compositingState());
CompositedLayerMapping* compositedLayerMapping = box->layer()->compositedLayerMapping();
ASSERT_TRUE(compositedLayerMapping->hasScrollingLayer());
ASSERT(compositedLayerMapping->scrollingContentsLayer());
GraphicsLayer* graphicsLayer = compositedLayerMapping->scrollingContentsLayer();
ASSERT_EQ(box->layer()->scrollableArea(), graphicsLayer->scrollableArea());
WebLayer* webScrollLayer = compositedLayerMapping->scrollingContentsLayer()->platformLayer();
ASSERT_TRUE(webScrollLayer->scrollable());
ASSERT_TRUE(webScrollLayer->userScrollableHorizontal());
ASSERT_TRUE(webScrollLayer->userScrollableVertical());
#if OS(ANDROID)
// Now verify we've attached impl-side scrollbars onto the scrollbar layers
ASSERT_TRUE(compositedLayerMapping->layerForHorizontalScrollbar());
ASSERT_TRUE(compositedLayerMapping->layerForHorizontalScrollbar()->hasContentsLayer());
ASSERT_TRUE(compositedLayerMapping->layerForVerticalScrollbar());
ASSERT_TRUE(compositedLayerMapping->layerForVerticalScrollbar()->hasContentsLayer());
#endif
}
TEST_F(ScrollingCoordinatorTest, rtlIframe)
{
registerMockedHttpURLLoad("rtl-iframe.html");
registerMockedHttpURLLoad("rtl-iframe-inner.html");
navigateTo(m_baseURL + "rtl-iframe.html");
forceFullCompositingUpdate();
// Verify the properties of the accelerated scrolling element starting from the LayoutObject
// all the way to the WebLayer.
Element* scrollableFrame = frame()->document()->getElementById("scrollable");
ASSERT_TRUE(scrollableFrame);
LayoutObject* layoutObject = scrollableFrame->layoutObject();
ASSERT_TRUE(layoutObject);
ASSERT_TRUE(layoutObject->isLayoutPart());
LayoutPart* layoutPart = toLayoutPart(layoutObject);
ASSERT_TRUE(layoutPart);
ASSERT_TRUE(layoutPart->widget());
ASSERT_TRUE(layoutPart->widget()->isFrameView());
FrameView* innerFrameView = toFrameView(layoutPart->widget());
LayoutView* innerLayoutView = innerFrameView->layoutView();
ASSERT_TRUE(innerLayoutView);
PaintLayerCompositor* innerCompositor = innerLayoutView->compositor();
ASSERT_TRUE(innerCompositor->inCompositingMode());
ASSERT_TRUE(innerCompositor->scrollLayer());
GraphicsLayer* scrollLayer = innerCompositor->scrollLayer();
ASSERT_EQ(innerFrameView, scrollLayer->scrollableArea());
WebLayer* webScrollLayer = scrollLayer->platformLayer();
ASSERT_TRUE(webScrollLayer->scrollable());
int expectedScrollPosition = 958 + (innerFrameView->verticalScrollbar()->isOverlayScrollbar() ? 0 : 15);
ASSERT_EQ(expectedScrollPosition, webScrollLayer->scrollPositionDouble().x);
}
TEST_F(ScrollingCoordinatorTest, setupScrollbarLayerShouldSetScrollLayerOpaque)
#endif
{
registerMockedHttpURLLoad("wide_document.html");
navigateTo(m_baseURL + "wide_document.html");
forceFullCompositingUpdate();
FrameView* frameView = frame()->view();
ASSERT_TRUE(frameView);
GraphicsLayer* scrollbarGraphicsLayer = frameView->layerForHorizontalScrollbar();
ASSERT_TRUE(scrollbarGraphicsLayer);
WebLayer* platformLayer = scrollbarGraphicsLayer->platformLayer();
ASSERT_TRUE(platformLayer);
WebLayer* contentsLayer = scrollbarGraphicsLayer->contentsLayer();
ASSERT_TRUE(contentsLayer);
// After scrollableAreaScrollbarLayerDidChange,
// if the main frame's scrollbarLayer is opaque,
// contentsLayer should be opaque too.
ASSERT_EQ(platformLayer->opaque(), contentsLayer->opaque());
}
int BasicMonster::doChargePlayer()
{
return navigateTo(lastSeenPlayer);
}
////////////////////////////////////////////////////////////////////////////////
// inherited from LLViewerMediaObserver
//virtual
void LLMediaCtrl::handleMediaEvent(LLPluginClassMedia* self, EMediaEvent event)
{
switch(event)
{
case MEDIA_EVENT_CONTENT_UPDATED:
{
// LL_DEBUGS("Media") << "Media event: MEDIA_EVENT_CONTENT_UPDATED " << LL_ENDL;
};
break;
case MEDIA_EVENT_TIME_DURATION_UPDATED:
{
// LL_DEBUGS("Media") << "Media event: MEDIA_EVENT_TIME_DURATION_UPDATED, time is " << self->getCurrentTime() << " of " << self->getDuration() << LL_ENDL;
};
break;
case MEDIA_EVENT_SIZE_CHANGED:
{
LL_DEBUGS("Media") << "Media event: MEDIA_EVENT_SIZE_CHANGED " << LL_ENDL;
LLRect r = getRect();
reshape( r.getWidth(), r.getHeight(), FALSE );
};
break;
case MEDIA_EVENT_CURSOR_CHANGED:
{
LL_DEBUGS("Media") << "Media event: MEDIA_EVENT_CURSOR_CHANGED, new cursor is " << self->getCursorName() << LL_ENDL;
}
break;
case MEDIA_EVENT_NAVIGATE_BEGIN:
{
LL_DEBUGS("Media") << "Media event: MEDIA_EVENT_NAVIGATE_BEGIN, url is " << self->getNavigateURI() << LL_ENDL;
hideNotification();
};
break;
case MEDIA_EVENT_NAVIGATE_COMPLETE:
{
LL_DEBUGS("Media") << "Media event: MEDIA_EVENT_NAVIGATE_COMPLETE, result string is: " << self->getNavigateResultString() << LL_ENDL;
if(mHidingInitialLoad)
{
mHidingInitialLoad = false;
}
};
break;
case MEDIA_EVENT_PROGRESS_UPDATED:
{
LL_DEBUGS("Media") << "Media event: MEDIA_EVENT_PROGRESS_UPDATED, loading at " << self->getProgressPercent() << "%" << LL_ENDL;
};
break;
case MEDIA_EVENT_STATUS_TEXT_CHANGED:
{
LL_DEBUGS("Media") << "Media event: MEDIA_EVENT_STATUS_TEXT_CHANGED, new status text is: " << self->getStatusText() << LL_ENDL;
};
break;
case MEDIA_EVENT_LOCATION_CHANGED:
{
LL_DEBUGS("Media") << "Media event: MEDIA_EVENT_LOCATION_CHANGED, new uri is: " << self->getLocation() << LL_ENDL;
mCurrentNavUrl = self->getLocation();
};
break;
case MEDIA_EVENT_NAVIGATE_ERROR_PAGE:
{
LL_DEBUGS("Media") << "Media event: MEDIA_EVENT_NAVIGATE_ERROR_PAGE" << LL_ENDL;
if ( mErrorPageURL.length() > 0 )
{
navigateTo(mErrorPageURL, "text/html");
};
};
break;
case MEDIA_EVENT_CLICK_LINK_HREF:
{
LL_DEBUGS("Media") << "Media event: MEDIA_EVENT_CLICK_LINK_HREF, target is \"" << self->getClickTarget() << "\", uri is " << self->getClickURL() << LL_ENDL;
// retrieve the event parameters
std::string url = self->getClickURL();
std::string target = self->getClickTarget();
std::string uuid = self->getClickUUID();
LLNotification::Params notify_params("PopupAttempt");
notify_params.payload = LLSD().with("target", target).with("url", url).with("uuid", uuid).with("media_id", mMediaTextureID);
notify_params.functor(boost::bind(&LLMediaCtrl::onPopup, this, _1, _2));
if (mTrusted)
{
LLNotifications::instance().forceResponse(notify_params, 0);
}
else
{
LLNotifications::instance().add(notify_params);
}
break;
};
case MEDIA_EVENT_CLICK_LINK_NOFOLLOW:
{
LL_DEBUGS("Media") << "Media event: MEDIA_EVENT_CLICK_LINK_NOFOLLOW, uri is " << self->getClickURL() << LL_ENDL;
};
break;
case MEDIA_EVENT_PLUGIN_FAILED:
{
LL_DEBUGS("Media") << "Media event: MEDIA_EVENT_PLUGIN_FAILED" << LL_ENDL;
};
break;
case MEDIA_EVENT_PLUGIN_FAILED_LAUNCH:
{
LL_DEBUGS("Media") << "Media event: MEDIA_EVENT_PLUGIN_FAILED_LAUNCH" << LL_ENDL;
};
break;
case MEDIA_EVENT_NAME_CHANGED:
{
LL_DEBUGS("Media") << "Media event: MEDIA_EVENT_NAME_CHANGED" << LL_ENDL;
};
break;
case MEDIA_EVENT_CLOSE_REQUEST:
{
LL_DEBUGS("Media") << "Media event: MEDIA_EVENT_CLOSE_REQUEST" << LL_ENDL;
}
break;
case MEDIA_EVENT_PICK_FILE_REQUEST:
{
LL_DEBUGS("Media") << "Media event: MEDIA_EVENT_PICK_FILE_REQUEST" << LL_ENDL;
}
break;
case MEDIA_EVENT_GEOMETRY_CHANGE:
{
LL_DEBUGS("Media") << "Media event: MEDIA_EVENT_GEOMETRY_CHANGE, uuid is " << self->getClickUUID() << LL_ENDL;
}
break;
case MEDIA_EVENT_AUTH_REQUEST:
{
LLNotification::Params auth_request_params("AuthRequest");
// pass in host name and realm for site (may be zero length but will always exist)
LLSD args;
LLURL raw_url( self->getAuthURL().c_str() );
args["HOST_NAME"] = raw_url.getAuthority();
args["REALM"] = self->getAuthRealm();
auth_request_params.substitutions = args;
auth_request_params.payload = LLSD().with("media_id", mMediaTextureID);
auth_request_params.functor(boost::bind(&LLViewerMedia::onAuthSubmit, _1, _2));
LLNotifications::instance().add(auth_request_params);
};
break;
case MEDIA_EVENT_LINK_HOVERED:
{
LL_DEBUGS("Media") << "Media event: MEDIA_EVENT_LINK_HOVERED, hover text is: " << self->getHoverText() << LL_ENDL;
mHoverTextChanged = true;
};
break;
case MEDIA_EVENT_DEBUG_MESSAGE:
{
LL_INFOS("media") << self->getDebugMessageText() << LL_ENDL;
};
break;
default:
{
LL_WARNS("Media") << "Media event: unknown event type" << LL_ENDL;
};
};
// chain all events to any potential observers of this object.
emitEvent(self, event);
}
int NavigationState::navigateToMine() {
navigateTo(true);
}
