Roll Chrome into Mojo.

cc/trees/layer_tree_impl.cc

 // Copyright 2011 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "cc/trees/layer_tree_impl.h"
 
 #include <limits>
 #include <set>
 
 #include "base/debug/trace_event.h"
@@ skipping 542 matching lines @@
 
     bool resourceless_software_draw = (layer_tree_host_impl_->GetDrawMode() ==
                                        DRAW_MODE_RESOURCELESS_SOFTWARE);
 
     // LayerIterator is used here instead of CallFunctionForSubtree to only
     // UpdateTilePriorities on layers that will be visible (and thus have valid
     // draw properties) and not because any ordering is required.
     typedef LayerIterator<LayerImpl> LayerIteratorType;
     LayerIteratorType end = LayerIteratorType::End(&render_surface_layer_list_);
     size_t layers_updated_count = 0;
+    bool tile_priorities_updated = false;
     for (LayerIteratorType it =
              LayerIteratorType::Begin(&render_surface_layer_list_);
          it != end;
          ++it) {
       if (occlusion_tracker)
         occlusion_tracker->EnterLayer(it);
 
       LayerImpl* layer = *it;
       const Occlusion& occlusion_in_content_space =
           occlusion_tracker ? occlusion_tracker->GetCurrentOcclusionForLayer(
                                   layer->draw_transform())
                             : Occlusion();
 
       if (it.represents_itself()) {
-        layer->UpdateTiles(occlusion_in_content_space,
-                           resourceless_software_draw);
+        tile_priorities_updated |= layer->UpdateTiles(
+            occlusion_in_content_space, resourceless_software_draw);
         ++layers_updated_count;
       }
 
       if (!it.represents_contributing_render_surface()) {
         if (occlusion_tracker)
           occlusion_tracker->LeaveLayer(it);
         continue;
       }
 
       if (layer->mask_layer()) {
-        layer->mask_layer()->UpdateTiles(occlusion_in_content_space,
-                                         resourceless_software_draw);
+        tile_priorities_updated |= layer->mask_layer()->UpdateTiles(
+            occlusion_in_content_space, resourceless_software_draw);
         ++layers_updated_count;
       }
       if (layer->replica_layer() && layer->replica_layer()->mask_layer()) {
-        layer->replica_layer()->mask_layer()->UpdateTiles(
-            occlusion_in_content_space, resourceless_software_draw);
+        tile_priorities_updated |=
+            layer->replica_layer()->mask_layer()->UpdateTiles(
+                occlusion_in_content_space, resourceless_software_draw);
         ++layers_updated_count;
       }
 
       if (occlusion_tracker)
         occlusion_tracker->LeaveLayer(it);
     }
 
+    if (tile_priorities_updated)
+      DidModifyTilePriorities();
+
     TRACE_EVENT_END1("cc", "LayerTreeImpl::UpdateTilePriorities",
                      "layers_updated_count", layers_updated_count);
   }
 
   DCHECK(!needs_update_draw_properties_) <<
       "CalcDrawProperties should not set_needs_update_draw_properties()";
   return true;
 }
 
 const LayerImplList& LayerTreeImpl::RenderSurfaceLayerList() const {
@@ skipping 461 matching lines @@
 ResourceProvider::ResourceId LayerTreeImpl::ResourceIdForUIResource(
     UIResourceId uid) const {
   return layer_tree_host_impl_->ResourceIdForUIResource(uid);
 }
 
 bool LayerTreeImpl::IsUIResourceOpaque(UIResourceId uid) const {
   return layer_tree_host_impl_->IsUIResourceOpaque(uid);
 }
 
 void LayerTreeImpl::ProcessUIResourceRequestQueue() {
-  while (ui_resource_request_queue_.size() > 0) {
-    UIResourceRequest req = ui_resource_request_queue_.front();
-    ui_resource_request_queue_.pop_front();
-
+  for (const auto& req : ui_resource_request_queue_) {
     switch (req.GetType()) {
       case UIResourceRequest::UIResourceCreate:
         layer_tree_host_impl_->CreateUIResource(req.GetId(), req.GetBitmap());
         break;
       case UIResourceRequest::UIResourceDelete:
         layer_tree_host_impl_->DeleteUIResource(req.GetId());
         break;
       case UIResourceRequest::UIResourceInvalidRequest:
         NOTREACHED();
         break;
     }
   }
+  ui_resource_request_queue_.clear();
 
   // If all UI resource evictions were not recreated by processing this queue,
   // then another commit is required.
   if (layer_tree_host_impl_->EvictedUIResourcesExist())
     layer_tree_host_impl_->SetNeedsCommit();
 }
 
 void LayerTreeImpl::AddLayerWithCopyOutputRequest(LayerImpl* layer) {
   // Only the active tree needs to know about layers with copy requests, as
   // they are aborted if not serviced during draw.
@@ skipping 410 matching lines @@
     scoped_ptr<PendingPageScaleAnimation> pending_animation) {
   pending_page_scale_animation_ = pending_animation.Pass();
 }
 
 scoped_ptr<PendingPageScaleAnimation>
     LayerTreeImpl::TakePendingPageScaleAnimation() {
   return pending_page_scale_animation_.Pass();
 }
 
 }  // namespace cc