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); }