layout/painting/nsDisplayList.cpp
changeset 591057 1b49e7328ae43c6565d167f4c391430575097fd3
parent 591056 8f3a50e16abc227d4ec698bf4a4126ea01d7ffc5
child 591065 bf228d1f3b4978e51ddd9939c225c7f51fde121f
equal deleted inserted replaced
591056:8f3a50e16abc 591057:1b49e7328ae4
   328   RefPtr<SourceSurface> maskSurface = maskDT->Snapshot();
   328   RefPtr<SourceSurface> maskSurface = maskDT->Snapshot();
   329   sourceCtx->PushGroupForBlendBack(gfxContentType::COLOR_ALPHA, 1.0,
   329   sourceCtx->PushGroupForBlendBack(gfxContentType::COLOR_ALPHA, 1.0,
   330                                    maskSurface, invCurrentMatrix);
   330                                    maskSurface, invCurrentMatrix);
   331 
   331 
   332   return true;
   332   return true;
   333 }
       
   334 
       
   335 /* static */
       
   336 void nsDisplayListBuilder::AddAnimationsAndTransitionsToLayer(
       
   337     Layer* aLayer, nsDisplayListBuilder* aBuilder, nsDisplayItem* aItem,
       
   338     nsIFrame* aFrame, DisplayItemType aType) {
       
   339   // This function can be called in two ways:  from
       
   340   // nsDisplay*::BuildLayer while constructing a layer (with all
       
   341   // pointers non-null), or from RestyleManager's handling of
       
   342   // UpdateOpacityLayer/UpdateTransformLayer hints.
       
   343   MOZ_ASSERT(!aBuilder == !aItem,
       
   344              "should only be called in two configurations, with both "
       
   345              "aBuilder and aItem, or with neither");
       
   346   MOZ_ASSERT(!aItem || aFrame == aItem->Frame(), "frame mismatch");
       
   347 
       
   348   // Only send animations to a layer that is actually using
       
   349   // off-main-thread compositing.
       
   350   LayersBackend backend = aLayer->Manager()->GetBackendType();
       
   351   if (!(backend == LayersBackend::LAYERS_CLIENT ||
       
   352         backend == LayersBackend::LAYERS_WR)) {
       
   353     return;
       
   354   }
       
   355 
       
   356   AnimationInfo& animationInfo = aLayer->GetAnimationInfo();
       
   357   animationInfo.AddAnimationsForDisplayItem(aFrame, aBuilder, aItem, aType,
       
   358                                             aLayer->Manager());
       
   359   animationInfo.TransferMutatedFlagToLayer(aLayer);
       
   360 }
   333 }
   361 
   334 
   362 nsDisplayWrapList* nsDisplayListBuilder::MergeItems(
   335 nsDisplayWrapList* nsDisplayListBuilder::MergeItems(
   363     nsTArray<nsDisplayWrapList*>& aItems) {
   336     nsTArray<nsDisplayWrapList*>& aItems) {
   364   // For merging, we create a temporary item by cloning the last item of the
   337   // For merging, we create a temporary item by cloning the last item of the
  2326 /**
  2299 /**
  2327  * We paint by executing a layer manager transaction, constructing a
  2300  * We paint by executing a layer manager transaction, constructing a
  2328  * single layer representing the display list, and then making it the
  2301  * single layer representing the display list, and then making it the
  2329  * root of the layer manager, drawing into the PaintedLayers.
  2302  * root of the layer manager, drawing into the PaintedLayers.
  2330  */
  2303  */
  2331 already_AddRefed<LayerManager> nsDisplayList::PaintRoot(
  2304 void nsDisplayList::PaintRoot(nsDisplayListBuilder* aBuilder, gfxContext* aCtx,
  2332     nsDisplayListBuilder* aBuilder, gfxContext* aCtx, uint32_t aFlags,
  2305                               uint32_t aFlags,
  2333     Maybe<double> aDisplayListBuildTime) {
  2306                               Maybe<double> aDisplayListBuildTime) {
  2334   AUTO_PROFILER_LABEL("nsDisplayList::PaintRoot", GRAPHICS);
  2307   AUTO_PROFILER_LABEL("nsDisplayList::PaintRoot", GRAPHICS);
  2335 
  2308 
  2336   RefPtr<WebRenderLayerManager> layerManager;
  2309   RefPtr<WebRenderLayerManager> layerManager;
  2337   WindowRenderer* renderer = nullptr;
  2310   WindowRenderer* renderer = nullptr;
  2338   bool widgetTransaction = false;
  2311   bool widgetTransaction = false;
  2360   Document* document = presShell->GetDocument();
  2333   Document* document = presShell->GetDocument();
  2361 
  2334 
  2362   if (!renderer) {
  2335   if (!renderer) {
  2363     if (!aCtx) {
  2336     if (!aCtx) {
  2364       NS_WARNING("Nowhere to paint into");
  2337       NS_WARNING("Nowhere to paint into");
  2365       return nullptr;
  2338       return;
  2366     }
  2339     }
  2367     bool prevIsCompositingCheap = aBuilder->SetIsCompositingCheap(false);
  2340     bool prevIsCompositingCheap = aBuilder->SetIsCompositingCheap(false);
  2368     Paint(aBuilder, aCtx, presContext->AppUnitsPerDevPixel());
  2341     Paint(aBuilder, aCtx, presContext->AppUnitsPerDevPixel());
  2369 
  2342 
  2370     if (document && document->IsBeingUsedAsImage()) {
  2343     if (document && document->IsBeingUsedAsImage()) {
  2371       frame->ClearInvalidationStateBits();
  2344       frame->ClearInvalidationStateBits();
  2372     }
  2345     }
  2373 
  2346 
  2374     aBuilder->SetIsCompositingCheap(prevIsCompositingCheap);
  2347     aBuilder->SetIsCompositingCheap(prevIsCompositingCheap);
  2375     return nullptr;
  2348     return;
  2376   }
  2349   }
  2377 
  2350 
  2378   if (renderer->GetBackendType() == LayersBackend::LAYERS_WR) {
  2351   if (renderer->GetBackendType() == LayersBackend::LAYERS_WR) {
  2379     MOZ_ASSERT(layerManager);
  2352     MOZ_ASSERT(layerManager);
  2380     if (doBeginTransaction) {
  2353     if (doBeginTransaction) {
  2381       if (aCtx) {
  2354       if (aCtx) {
  2382         if (!layerManager->BeginTransactionWithTarget(aCtx, nsCString())) {
  2355         if (!layerManager->BeginTransactionWithTarget(aCtx, nsCString())) {
  2383           return nullptr;
  2356           return;
  2384         }
  2357         }
  2385       } else {
  2358       } else {
  2386         if (!layerManager->BeginTransaction(nsCString())) {
  2359         if (!layerManager->BeginTransaction(nsCString())) {
  2387           return nullptr;
  2360           return;
  2388         }
  2361         }
  2389       }
  2362       }
  2390     }
  2363     }
  2391 
  2364 
  2392     bool prevIsCompositingCheap = aBuilder->SetIsCompositingCheap(true);
  2365     bool prevIsCompositingCheap = aBuilder->SetIsCompositingCheap(true);
  2434     if (presContext->RefreshDriver()->HasScheduleFlush()) {
  2407     if (presContext->RefreshDriver()->HasScheduleFlush()) {
  2435       presContext->NotifyInvalidation(layerManager->GetLastTransactionId(),
  2408       presContext->NotifyInvalidation(layerManager->GetLastTransactionId(),
  2436                                       frame->GetRect());
  2409                                       frame->GetRect());
  2437     }
  2410     }
  2438 
  2411 
  2439     return layerManager.forget();
  2412     return;
  2440   }
  2413   }
  2441 
  2414 
  2442   FallbackRenderer* fallback = renderer->AsFallback();
  2415   FallbackRenderer* fallback = renderer->AsFallback();
  2443   MOZ_ASSERT(fallback);
  2416   MOZ_ASSERT(fallback);
  2444 
  2417 
  2445   if (doBeginTransaction) {
  2418   if (doBeginTransaction) {
  2446     MOZ_ASSERT(!aCtx);
  2419     MOZ_ASSERT(!aCtx);
  2447     if (!fallback->BeginTransaction()) {
  2420     if (!fallback->BeginTransaction()) {
  2448       return nullptr;
  2421       return;
  2449     }
  2422     }
  2450   }
  2423   }
  2451 
  2424 
  2452   bool temp = aBuilder->SetIsCompositingCheap(renderer->IsCompositingCheap());
  2425   bool temp = aBuilder->SetIsCompositingCheap(renderer->IsCompositingCheap());
  2453   LayerManager::EndTransactionFlags flags = LayerManager::END_DEFAULT;
  2426   LayerManager::EndTransactionFlags flags = LayerManager::END_DEFAULT;
  2480       // anything else.
  2453       // anything else.
  2481       NS_ASSERTION(!(aFlags & PAINT_NO_COMPOSITE),
  2454       NS_ASSERTION(!(aFlags & PAINT_NO_COMPOSITE),
  2482                    "Must be compositing during fallback");
  2455                    "Must be compositing during fallback");
  2483     }
  2456     }
  2484   }
  2457   }
  2485   return nullptr;
  2458   return;
  2486 }
  2459 }
  2487 
  2460 
  2488 nsDisplayItem* nsDisplayList::RemoveBottom() {
  2461 nsDisplayItem* nsDisplayList::RemoveBottom() {
  2489   nsDisplayItem* item = mSentinel.mAbove;
  2462   nsDisplayItem* item = mSentinel.mAbove;
  2490   if (!item) {
  2463   if (!item) {
  6172   MOZ_COUNT_CTOR(nsDisplayScrollInfoLayer);
  6145   MOZ_COUNT_CTOR(nsDisplayScrollInfoLayer);
  6173 #endif
  6146 #endif
  6174 }
  6147 }
  6175 
  6148 
  6176 UniquePtr<ScrollMetadata> nsDisplayScrollInfoLayer::ComputeScrollMetadata(
  6149 UniquePtr<ScrollMetadata> nsDisplayScrollInfoLayer::ComputeScrollMetadata(
  6177     nsDisplayListBuilder* aBuilder, LayerManager* aLayerManager) {
  6150     nsDisplayListBuilder* aBuilder, WebRenderLayerManager* aLayerManager) {
  6178   ScrollMetadata metadata = nsLayoutUtils::ComputeScrollMetadata(
  6151   ScrollMetadata metadata = nsLayoutUtils::ComputeScrollMetadata(
  6179       mScrolledFrame, mScrollFrame, mScrollFrame->GetContent(),
  6152       mScrolledFrame, mScrollFrame, mScrollFrame->GetContent(),
  6180       ReferenceFrame(), aLayerManager, mScrollParentId, mScrollFrame->GetSize(),
  6153       ReferenceFrame(), aLayerManager, mScrollParentId, mScrollFrame->GetSize(),
  6181       Nothing(), false);
  6154       Nothing(), false);
  6182   metadata.GetMetrics().SetIsScrollInfoLayer(true);
  6155   metadata.GetMetrics().SetIsScrollInfoLayer(true);